
# Automatically generated by Numbast Static Binding Generator
# Generator Information:
# Ast_canopy version: 0.5.4
# Numbast version: 0.5.4
# Generation command: /data/tmp/main_nvshmem/build/externals/numbast/numbast/numbast/src/numbast/__main__.py --cfg-path /data/tmp/main_nvshmem/build/externals/numbast/build_assets/numbast/config_nvshmem.yml --output-dir /data/tmp/main_nvshmem/build/externals/numbast/out --bypass-parse-error true
# Static binding generator parameters: {'cfg_path': '/data/tmp/main_nvshmem/build/externals/numbast/build_assets/numbast/config_nvshmem.yml', 'output_dir': '/data/tmp/main_nvshmem/build/externals/numbast/out', 'bypass_parse_error': True, 'run_ruff_format': True}
# Config file path (relative to the path of the generated binding): ../../build_assets/numbast/config_nvshmem.yml
# Cudatoolkit version: (12, 9)
# Default CUDA_HOME path: /dvs/p4/build/sw/rel/gpgpu/toolkit/r12.9/build/cuda


# Imports:
from numba.types import float16
from numba.cuda import declare_device
from numba.types import float32
from numba.cuda.cudaimpl import lower_constant
from numba.cuda.vector_types import vector_types
from numba.core.typing import signature
from numba.types import int32
from numba.core.extending import lower_cast
from numba.types import CPointer
import numba
from numba.types import int64
from numba.types import uint32
from numba.cuda.types import bfloat16
from numba.types import uint8
from numba.cuda.cudaimpl import lower_attr
from numba.types import uint16
from numba.cuda.cudadecl import register_global
from numba.cuda.typing.templates import ConcreteTemplate
from numba.cuda import CUSource
from numba.types import int8
from numba.cuda.cudaimpl import lower
from numba.types import void
import io
from numba.cuda.cudadecl import register
from numba.types import int16
from numba.types import float64
from numba.types import uint64
from numba.cuda.cudadecl import register_attr
from numba.types import bool_
from numba import types
import nvshmem.bindings


float64x2 = vector_types['float64x2']


# Shim Stream:

class _KeyedStringIO(io.StringIO):
    def __init__(self, *arg, **kwarg):
        super().__init__(*arg, *kwarg)
        self._keys = set()

    def write_with_key(self, key: str, value: str):
        if key in self._keys:
            return
        self._keys.add(key)
        self.write(value)

    def reset(self):
        self._keys.clear()
        self.seek(0)


shim_defines = "#define __NVSHMEM_NUMBA_SUPPORT__"
shim_include = '#include <' + "entry_point.h" + '>'
shim_prefix = shim_defines + "\n" + shim_include
shim_stream = _KeyedStringIO()
shim_stream.write(shim_prefix)
shim_obj = CUSource(shim_stream)

shim_obj.setup_callback = lambda x: nvshmem.bindings.cumodule_init(int(x))
shim_obj.teardown_callback = lambda x: nvshmem.bindings.cumodule_finalize(int(x))

# Enums:


# Structs:


# Functions:


def team_my_pe():
    pass
    

def _lower__Z18nvshmem_team_my_pe_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_team_my_pe_nbst(int &retval , int* team) {
        retval = nvshmem_team_my_pe(*team);
        return 0;
    }
        """


    _Z18nvshmem_team_my_pe_nbst = declare_device(
        '_Z18nvshmem_team_my_pe_nbst',
        int32(
            CPointer(int32)
        )
    )
    

    def _Z18nvshmem_team_my_pe_nbst_caller(arg_0):
        return _Z18nvshmem_team_my_pe_nbst(arg_0)
    

    @lower(team_my_pe, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_team_my_pe_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_team_my_pe_nbst_caller,
            signature(int32, CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_team_my_pe_nbst(shim_stream, shim_obj)


def team_n_pes():
    pass
    

def _lower__Z18nvshmem_team_n_pes_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_team_n_pes_nbst(int &retval , int* team) {
        retval = nvshmem_team_n_pes(*team);
        return 0;
    }
        """


    _Z18nvshmem_team_n_pes_nbst = declare_device(
        '_Z18nvshmem_team_n_pes_nbst',
        int32(
            CPointer(int32)
        )
    )
    

    def _Z18nvshmem_team_n_pes_nbst_caller(arg_0):
        return _Z18nvshmem_team_n_pes_nbst(arg_0)
    

    @lower(team_n_pes, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_team_n_pes_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_team_n_pes_nbst_caller,
            signature(int32, CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_team_n_pes_nbst(shim_stream, shim_obj)


def team_translate_pe():
    pass
    

def _lower__Z25nvshmem_team_translate_pe_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_team_translate_pe_nbst(int &retval , int* src_team, int* src_pe, int* dest_team) {
        retval = nvshmem_team_translate_pe(*src_team, *src_pe, *dest_team);
        return 0;
    }
        """


    _Z25nvshmem_team_translate_pe_nbst = declare_device(
        '_Z25nvshmem_team_translate_pe_nbst',
        int32(
            CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_team_translate_pe_nbst_caller(arg_0, arg_1, arg_2):
        return _Z25nvshmem_team_translate_pe_nbst(arg_0, arg_1, arg_2)
    

    @lower(team_translate_pe, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_team_translate_pe_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_team_translate_pe_nbst_caller,
            signature(int32, CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_team_translate_pe_nbst(shim_stream, shim_obj)


def my_pe():
    pass
    

def _lower__Z13nvshmem_my_pe_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z13nvshmem_my_pe_nbst(int &retval ) {
        retval = nvshmem_my_pe();
        return 0;
    }
        """


    _Z13nvshmem_my_pe_nbst = declare_device(
        '_Z13nvshmem_my_pe_nbst',
        int32(
        
        )
    )
    

    def _Z13nvshmem_my_pe_nbst_caller():
        return _Z13nvshmem_my_pe_nbst()
    

    @lower(my_pe, )
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z13nvshmem_my_pe_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z13nvshmem_my_pe_nbst_caller,
            signature(int32, ),
            ptrs,
        )



_lower__Z13nvshmem_my_pe_nbst(shim_stream, shim_obj)


def n_pes():
    pass
    

def _lower__Z13nvshmem_n_pes_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z13nvshmem_n_pes_nbst(int &retval ) {
        retval = nvshmem_n_pes();
        return 0;
    }
        """


    _Z13nvshmem_n_pes_nbst = declare_device(
        '_Z13nvshmem_n_pes_nbst',
        int32(
        
        )
    )
    

    def _Z13nvshmem_n_pes_nbst_caller():
        return _Z13nvshmem_n_pes_nbst()
    

    @lower(n_pes, )
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z13nvshmem_n_pes_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z13nvshmem_n_pes_nbst_caller,
            signature(int32, ),
            ptrs,
        )



_lower__Z13nvshmem_n_pes_nbst(shim_stream, shim_obj)


def info_get_name():
    pass
    

def _lower__Z21nvshmem_info_get_name_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_info_get_name_nbst(int &retval , char ** name) {
        nvshmem_info_get_name(*name);
        return 0;
    }
        """


    _Z21nvshmem_info_get_name_nbst = declare_device(
        '_Z21nvshmem_info_get_name_nbst',
        void(
            CPointer(CPointer(int8))
        )
    )
    

    def _Z21nvshmem_info_get_name_nbst_caller(arg_0):
        return _Z21nvshmem_info_get_name_nbst(arg_0)
    

    @lower(info_get_name, CPointer(int8))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_info_get_name_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_info_get_name_nbst_caller,
            signature(void, CPointer(CPointer(int8))),
            ptrs,
        )



_lower__Z21nvshmem_info_get_name_nbst(shim_stream, shim_obj)


def info_get_version():
    pass
    

def _lower__Z24nvshmem_info_get_version_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_info_get_version_nbst(int &retval , int ** major, int ** minor) {
        nvshmem_info_get_version(*major, *minor);
        return 0;
    }
        """


    _Z24nvshmem_info_get_version_nbst = declare_device(
        '_Z24nvshmem_info_get_version_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32))
        )
    )
    

    def _Z24nvshmem_info_get_version_nbst_caller(arg_0, arg_1):
        return _Z24nvshmem_info_get_version_nbst(arg_0, arg_1)
    

    @lower(info_get_version, CPointer(int32), CPointer(int32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_info_get_version_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_info_get_version_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32))),
            ptrs,
        )



_lower__Z24nvshmem_info_get_version_nbst(shim_stream, shim_obj)


def bfloat16_p():
    pass
    

def _lower__Z18nvshmem_bfloat16_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_bfloat16_p_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16* value, int* pe) {
        nvshmem_bfloat16_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z18nvshmem_bfloat16_p_nbst = declare_device(
        '_Z18nvshmem_bfloat16_p_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(bfloat16), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_bfloat16_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z18nvshmem_bfloat16_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(bfloat16_p, CPointer(bfloat16), bfloat16, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_bfloat16_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_bfloat16_p_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(bfloat16), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_bfloat16_p_nbst(shim_stream, shim_obj)


def half_p():
    pass
    

def _lower__Z14nvshmem_half_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_half_p_nbst(int &retval , __half ** dest, __half* value, int* pe) {
        nvshmem_half_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z14nvshmem_half_p_nbst = declare_device(
        '_Z14nvshmem_half_p_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(float16), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_half_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z14nvshmem_half_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(half_p, CPointer(float16), float16, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_half_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_half_p_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(float16), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_half_p_nbst(shim_stream, shim_obj)


def float_p():
    pass
    

def _lower__Z15nvshmem_float_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_float_p_nbst(int &retval , float ** dest, float* value, int* pe) {
        nvshmem_float_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z15nvshmem_float_p_nbst = declare_device(
        '_Z15nvshmem_float_p_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(float32), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_float_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z15nvshmem_float_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(float_p, CPointer(float32), float32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_float_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_float_p_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(float32), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_float_p_nbst(shim_stream, shim_obj)


def double_p():
    pass
    

def _lower__Z16nvshmem_double_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_double_p_nbst(int &retval , double ** dest, double* value, int* pe) {
        nvshmem_double_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z16nvshmem_double_p_nbst = declare_device(
        '_Z16nvshmem_double_p_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(float64), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_double_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z16nvshmem_double_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(double_p, CPointer(float64), float64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_double_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_double_p_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(float64), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_double_p_nbst(shim_stream, shim_obj)


def char_p():
    pass
    

def _lower__Z14nvshmem_char_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_char_p_nbst(int &retval , char ** dest, char* value, int* pe) {
        nvshmem_char_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z14nvshmem_char_p_nbst = declare_device(
        '_Z14nvshmem_char_p_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(int8), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_char_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z14nvshmem_char_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(char_p, CPointer(int8), int8, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_char_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_char_p_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(int8), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_char_p_nbst(shim_stream, shim_obj)


def short_p():
    pass
    

def _lower__Z15nvshmem_short_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_short_p_nbst(int &retval , short ** dest, short* value, int* pe) {
        nvshmem_short_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z15nvshmem_short_p_nbst = declare_device(
        '_Z15nvshmem_short_p_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(int16), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_short_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z15nvshmem_short_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(short_p, CPointer(int16), int16, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_short_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_short_p_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(int16), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_short_p_nbst(shim_stream, shim_obj)


def schar_p():
    pass
    

def _lower__Z15nvshmem_schar_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_schar_p_nbst(int &retval , signed char ** dest, signed char* value, int* pe) {
        nvshmem_schar_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z15nvshmem_schar_p_nbst = declare_device(
        '_Z15nvshmem_schar_p_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(int8), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_schar_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z15nvshmem_schar_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(schar_p, CPointer(int8), int8, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_schar_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_schar_p_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(int8), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_schar_p_nbst(shim_stream, shim_obj)


def int_p():
    pass
    

def _lower__Z13nvshmem_int_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z13nvshmem_int_p_nbst(int &retval , int ** dest, int* value, int* pe) {
        nvshmem_int_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z13nvshmem_int_p_nbst = declare_device(
        '_Z13nvshmem_int_p_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z13nvshmem_int_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z13nvshmem_int_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(int_p, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z13nvshmem_int_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z13nvshmem_int_p_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z13nvshmem_int_p_nbst(shim_stream, shim_obj)


def long_p():
    pass
    

def _lower__Z14nvshmem_long_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_long_p_nbst(int &retval , long ** dest, long* value, int* pe) {
        nvshmem_long_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z14nvshmem_long_p_nbst = declare_device(
        '_Z14nvshmem_long_p_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_long_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z14nvshmem_long_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(long_p, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_long_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_long_p_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_long_p_nbst(shim_stream, shim_obj)


def longlong_p():
    pass
    

def _lower__Z18nvshmem_longlong_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_longlong_p_nbst(int &retval , long long ** dest, long long* value, int* pe) {
        nvshmem_longlong_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z18nvshmem_longlong_p_nbst = declare_device(
        '_Z18nvshmem_longlong_p_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_longlong_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z18nvshmem_longlong_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(longlong_p, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_longlong_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_longlong_p_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_longlong_p_nbst(shim_stream, shim_obj)


def uchar_p():
    pass
    

def _lower__Z15nvshmem_uchar_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_uchar_p_nbst(int &retval , unsigned char ** dest, unsigned char* value, int* pe) {
        nvshmem_uchar_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z15nvshmem_uchar_p_nbst = declare_device(
        '_Z15nvshmem_uchar_p_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(uint8), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_uchar_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z15nvshmem_uchar_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(uchar_p, CPointer(uint8), uint8, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_uchar_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_uchar_p_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(uint8), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_uchar_p_nbst(shim_stream, shim_obj)


def ushort_p():
    pass
    

def _lower__Z16nvshmem_ushort_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_ushort_p_nbst(int &retval , unsigned short ** dest, unsigned short* value, int* pe) {
        nvshmem_ushort_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z16nvshmem_ushort_p_nbst = declare_device(
        '_Z16nvshmem_ushort_p_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(uint16), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_ushort_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z16nvshmem_ushort_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(ushort_p, CPointer(uint16), uint16, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_ushort_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_ushort_p_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(uint16), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_ushort_p_nbst(shim_stream, shim_obj)


def uint_p():
    pass
    

def _lower__Z14nvshmem_uint_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_uint_p_nbst(int &retval , unsigned int ** dest, unsigned int* value, int* pe) {
        nvshmem_uint_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z14nvshmem_uint_p_nbst = declare_device(
        '_Z14nvshmem_uint_p_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_uint_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z14nvshmem_uint_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint_p, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_uint_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_uint_p_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_uint_p_nbst(shim_stream, shim_obj)


def ulong_p():
    pass
    

def _lower__Z15nvshmem_ulong_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_ulong_p_nbst(int &retval , unsigned long ** dest, unsigned long* value, int* pe) {
        nvshmem_ulong_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z15nvshmem_ulong_p_nbst = declare_device(
        '_Z15nvshmem_ulong_p_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_ulong_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z15nvshmem_ulong_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulong_p, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_ulong_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_ulong_p_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_ulong_p_nbst(shim_stream, shim_obj)


def ulonglong_p():
    pass
    

def _lower__Z19nvshmem_ulonglong_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_ulonglong_p_nbst(int &retval , unsigned long long ** dest, unsigned long long* value, int* pe) {
        nvshmem_ulonglong_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z19nvshmem_ulonglong_p_nbst = declare_device(
        '_Z19nvshmem_ulonglong_p_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmem_ulonglong_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z19nvshmem_ulonglong_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulonglong_p, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmem_ulonglong_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_ulonglong_p_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmem_ulonglong_p_nbst(shim_stream, shim_obj)


def int8_p():
    pass
    

def _lower__Z14nvshmem_int8_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_int8_p_nbst(int &retval , int8_t ** dest, int8_t* value, int* pe) {
        nvshmem_int8_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z14nvshmem_int8_p_nbst = declare_device(
        '_Z14nvshmem_int8_p_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(int8), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_int8_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z14nvshmem_int8_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(int8_p, CPointer(int8), int8, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_int8_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_int8_p_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(int8), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_int8_p_nbst(shim_stream, shim_obj)


def int16_p():
    pass
    

def _lower__Z15nvshmem_int16_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_int16_p_nbst(int &retval , int16_t ** dest, int16_t* value, int* pe) {
        nvshmem_int16_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z15nvshmem_int16_p_nbst = declare_device(
        '_Z15nvshmem_int16_p_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(int16), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_int16_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z15nvshmem_int16_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(int16_p, CPointer(int16), int16, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_int16_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_int16_p_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(int16), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_int16_p_nbst(shim_stream, shim_obj)


def int32_p():
    pass
    

def _lower__Z15nvshmem_int32_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_int32_p_nbst(int &retval , int32_t ** dest, int32_t* value, int* pe) {
        nvshmem_int32_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z15nvshmem_int32_p_nbst = declare_device(
        '_Z15nvshmem_int32_p_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_int32_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z15nvshmem_int32_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(int32_p, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_int32_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_int32_p_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_int32_p_nbst(shim_stream, shim_obj)


def int64_p():
    pass
    

def _lower__Z15nvshmem_int64_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_int64_p_nbst(int &retval , int64_t ** dest, int64_t* value, int* pe) {
        nvshmem_int64_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z15nvshmem_int64_p_nbst = declare_device(
        '_Z15nvshmem_int64_p_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_int64_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z15nvshmem_int64_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(int64_p, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_int64_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_int64_p_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_int64_p_nbst(shim_stream, shim_obj)


def uint8_p():
    pass
    

def _lower__Z15nvshmem_uint8_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_uint8_p_nbst(int &retval , uint8_t ** dest, uint8_t* value, int* pe) {
        nvshmem_uint8_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z15nvshmem_uint8_p_nbst = declare_device(
        '_Z15nvshmem_uint8_p_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(uint8), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_uint8_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z15nvshmem_uint8_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint8_p, CPointer(uint8), uint8, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_uint8_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_uint8_p_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(uint8), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_uint8_p_nbst(shim_stream, shim_obj)


def uint16_p():
    pass
    

def _lower__Z16nvshmem_uint16_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_uint16_p_nbst(int &retval , uint16_t ** dest, uint16_t* value, int* pe) {
        nvshmem_uint16_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z16nvshmem_uint16_p_nbst = declare_device(
        '_Z16nvshmem_uint16_p_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(uint16), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_uint16_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z16nvshmem_uint16_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint16_p, CPointer(uint16), uint16, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_uint16_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_uint16_p_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(uint16), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_uint16_p_nbst(shim_stream, shim_obj)


def uint32_p():
    pass
    

def _lower__Z16nvshmem_uint32_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_uint32_p_nbst(int &retval , uint32_t ** dest, uint32_t* value, int* pe) {
        nvshmem_uint32_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z16nvshmem_uint32_p_nbst = declare_device(
        '_Z16nvshmem_uint32_p_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_uint32_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z16nvshmem_uint32_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint32_p, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_uint32_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_uint32_p_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_uint32_p_nbst(shim_stream, shim_obj)


def uint64_p():
    pass
    

def _lower__Z16nvshmem_uint64_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_uint64_p_nbst(int &retval , uint64_t ** dest, uint64_t* value, int* pe) {
        nvshmem_uint64_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z16nvshmem_uint64_p_nbst = declare_device(
        '_Z16nvshmem_uint64_p_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_uint64_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z16nvshmem_uint64_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint64_p, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_uint64_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_uint64_p_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_uint64_p_nbst(shim_stream, shim_obj)


def size_p():
    pass
    

def _lower__Z14nvshmem_size_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_size_p_nbst(int &retval , unsigned long ** dest, unsigned long* value, int* pe) {
        nvshmem_size_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z14nvshmem_size_p_nbst = declare_device(
        '_Z14nvshmem_size_p_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_size_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z14nvshmem_size_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(size_p, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_size_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_size_p_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_size_p_nbst(shim_stream, shim_obj)


def ptrdiff_p():
    pass
    

def _lower__Z17nvshmem_ptrdiff_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_ptrdiff_p_nbst(int &retval , long ** dest, long* value, int* pe) {
        nvshmem_ptrdiff_p(*dest, *value, *pe);
        return 0;
    }
        """


    _Z17nvshmem_ptrdiff_p_nbst = declare_device(
        '_Z17nvshmem_ptrdiff_p_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_ptrdiff_p_nbst_caller(arg_0, arg_1, arg_2):
        return _Z17nvshmem_ptrdiff_p_nbst(arg_0, arg_1, arg_2)
    

    @lower(ptrdiff_p, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_ptrdiff_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_ptrdiff_p_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_ptrdiff_p_nbst(shim_stream, shim_obj)


def bfloat16_g():
    pass
    

def _lower__Z18nvshmem_bfloat16_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_bfloat16_g_nbst(__nv_bfloat16 &retval , __nv_bfloat16 ** source, int* pe) {
        retval = nvshmem_bfloat16_g(*source, *pe);
        return 0;
    }
        """


    _Z18nvshmem_bfloat16_g_nbst = declare_device(
        '_Z18nvshmem_bfloat16_g_nbst',
        bfloat16(
            CPointer(CPointer(bfloat16)), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_bfloat16_g_nbst_caller(arg_0, arg_1):
        return _Z18nvshmem_bfloat16_g_nbst(arg_0, arg_1)
    

    @lower(bfloat16_g, CPointer(bfloat16), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_bfloat16_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_bfloat16_g_nbst_caller,
            signature(bfloat16, CPointer(CPointer(bfloat16)), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_bfloat16_g_nbst(shim_stream, shim_obj)


def half_g():
    pass
    

def _lower__Z14nvshmem_half_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_half_g_nbst(__half &retval , __half ** source, int* pe) {
        retval = nvshmem_half_g(*source, *pe);
        return 0;
    }
        """


    _Z14nvshmem_half_g_nbst = declare_device(
        '_Z14nvshmem_half_g_nbst',
        float16(
            CPointer(CPointer(float16)), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_half_g_nbst_caller(arg_0, arg_1):
        return _Z14nvshmem_half_g_nbst(arg_0, arg_1)
    

    @lower(half_g, CPointer(float16), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_half_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_half_g_nbst_caller,
            signature(float16, CPointer(CPointer(float16)), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_half_g_nbst(shim_stream, shim_obj)


def float_g():
    pass
    

def _lower__Z15nvshmem_float_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_float_g_nbst(float &retval , float ** source, int* pe) {
        retval = nvshmem_float_g(*source, *pe);
        return 0;
    }
        """


    _Z15nvshmem_float_g_nbst = declare_device(
        '_Z15nvshmem_float_g_nbst',
        float32(
            CPointer(CPointer(float32)), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_float_g_nbst_caller(arg_0, arg_1):
        return _Z15nvshmem_float_g_nbst(arg_0, arg_1)
    

    @lower(float_g, CPointer(float32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_float_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_float_g_nbst_caller,
            signature(float32, CPointer(CPointer(float32)), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_float_g_nbst(shim_stream, shim_obj)


def double_g():
    pass
    

def _lower__Z16nvshmem_double_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_double_g_nbst(double &retval , double ** source, int* pe) {
        retval = nvshmem_double_g(*source, *pe);
        return 0;
    }
        """


    _Z16nvshmem_double_g_nbst = declare_device(
        '_Z16nvshmem_double_g_nbst',
        float64(
            CPointer(CPointer(float64)), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_double_g_nbst_caller(arg_0, arg_1):
        return _Z16nvshmem_double_g_nbst(arg_0, arg_1)
    

    @lower(double_g, CPointer(float64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_double_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_double_g_nbst_caller,
            signature(float64, CPointer(CPointer(float64)), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_double_g_nbst(shim_stream, shim_obj)


def char_g():
    pass
    

def _lower__Z14nvshmem_char_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_char_g_nbst(char &retval , char ** source, int* pe) {
        retval = nvshmem_char_g(*source, *pe);
        return 0;
    }
        """


    _Z14nvshmem_char_g_nbst = declare_device(
        '_Z14nvshmem_char_g_nbst',
        int8(
            CPointer(CPointer(int8)), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_char_g_nbst_caller(arg_0, arg_1):
        return _Z14nvshmem_char_g_nbst(arg_0, arg_1)
    

    @lower(char_g, CPointer(int8), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_char_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_char_g_nbst_caller,
            signature(int8, CPointer(CPointer(int8)), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_char_g_nbst(shim_stream, shim_obj)


def short_g():
    pass
    

def _lower__Z15nvshmem_short_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_short_g_nbst(short &retval , short ** source, int* pe) {
        retval = nvshmem_short_g(*source, *pe);
        return 0;
    }
        """


    _Z15nvshmem_short_g_nbst = declare_device(
        '_Z15nvshmem_short_g_nbst',
        int16(
            CPointer(CPointer(int16)), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_short_g_nbst_caller(arg_0, arg_1):
        return _Z15nvshmem_short_g_nbst(arg_0, arg_1)
    

    @lower(short_g, CPointer(int16), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_short_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_short_g_nbst_caller,
            signature(int16, CPointer(CPointer(int16)), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_short_g_nbst(shim_stream, shim_obj)


def schar_g():
    pass
    

def _lower__Z15nvshmem_schar_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_schar_g_nbst(signed char &retval , signed char ** source, int* pe) {
        retval = nvshmem_schar_g(*source, *pe);
        return 0;
    }
        """


    _Z15nvshmem_schar_g_nbst = declare_device(
        '_Z15nvshmem_schar_g_nbst',
        int8(
            CPointer(CPointer(int8)), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_schar_g_nbst_caller(arg_0, arg_1):
        return _Z15nvshmem_schar_g_nbst(arg_0, arg_1)
    

    @lower(schar_g, CPointer(int8), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_schar_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_schar_g_nbst_caller,
            signature(int8, CPointer(CPointer(int8)), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_schar_g_nbst(shim_stream, shim_obj)


def int_g():
    pass
    

def _lower__Z13nvshmem_int_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z13nvshmem_int_g_nbst(int &retval , int ** source, int* pe) {
        retval = nvshmem_int_g(*source, *pe);
        return 0;
    }
        """


    _Z13nvshmem_int_g_nbst = declare_device(
        '_Z13nvshmem_int_g_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(int32)
        )
    )
    

    def _Z13nvshmem_int_g_nbst_caller(arg_0, arg_1):
        return _Z13nvshmem_int_g_nbst(arg_0, arg_1)
    

    @lower(int_g, CPointer(int32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z13nvshmem_int_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z13nvshmem_int_g_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(int32)),
            ptrs,
        )



_lower__Z13nvshmem_int_g_nbst(shim_stream, shim_obj)


def long_g():
    pass
    

def _lower__Z14nvshmem_long_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_long_g_nbst(long &retval , long ** source, int* pe) {
        retval = nvshmem_long_g(*source, *pe);
        return 0;
    }
        """


    _Z14nvshmem_long_g_nbst = declare_device(
        '_Z14nvshmem_long_g_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_long_g_nbst_caller(arg_0, arg_1):
        return _Z14nvshmem_long_g_nbst(arg_0, arg_1)
    

    @lower(long_g, CPointer(int64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_long_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_long_g_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_long_g_nbst(shim_stream, shim_obj)


def longlong_g():
    pass
    

def _lower__Z18nvshmem_longlong_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_longlong_g_nbst(long long &retval , long long ** source, int* pe) {
        retval = nvshmem_longlong_g(*source, *pe);
        return 0;
    }
        """


    _Z18nvshmem_longlong_g_nbst = declare_device(
        '_Z18nvshmem_longlong_g_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_longlong_g_nbst_caller(arg_0, arg_1):
        return _Z18nvshmem_longlong_g_nbst(arg_0, arg_1)
    

    @lower(longlong_g, CPointer(int64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_longlong_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_longlong_g_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_longlong_g_nbst(shim_stream, shim_obj)


def uchar_g():
    pass
    

def _lower__Z15nvshmem_uchar_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_uchar_g_nbst(unsigned char &retval , unsigned char ** source, int* pe) {
        retval = nvshmem_uchar_g(*source, *pe);
        return 0;
    }
        """


    _Z15nvshmem_uchar_g_nbst = declare_device(
        '_Z15nvshmem_uchar_g_nbst',
        uint8(
            CPointer(CPointer(uint8)), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_uchar_g_nbst_caller(arg_0, arg_1):
        return _Z15nvshmem_uchar_g_nbst(arg_0, arg_1)
    

    @lower(uchar_g, CPointer(uint8), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_uchar_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_uchar_g_nbst_caller,
            signature(uint8, CPointer(CPointer(uint8)), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_uchar_g_nbst(shim_stream, shim_obj)


def ushort_g():
    pass
    

def _lower__Z16nvshmem_ushort_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_ushort_g_nbst(unsigned short &retval , unsigned short ** source, int* pe) {
        retval = nvshmem_ushort_g(*source, *pe);
        return 0;
    }
        """


    _Z16nvshmem_ushort_g_nbst = declare_device(
        '_Z16nvshmem_ushort_g_nbst',
        uint16(
            CPointer(CPointer(uint16)), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_ushort_g_nbst_caller(arg_0, arg_1):
        return _Z16nvshmem_ushort_g_nbst(arg_0, arg_1)
    

    @lower(ushort_g, CPointer(uint16), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_ushort_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_ushort_g_nbst_caller,
            signature(uint16, CPointer(CPointer(uint16)), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_ushort_g_nbst(shim_stream, shim_obj)


def uint_g():
    pass
    

def _lower__Z14nvshmem_uint_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_uint_g_nbst(unsigned int &retval , unsigned int ** source, int* pe) {
        retval = nvshmem_uint_g(*source, *pe);
        return 0;
    }
        """


    _Z14nvshmem_uint_g_nbst = declare_device(
        '_Z14nvshmem_uint_g_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_uint_g_nbst_caller(arg_0, arg_1):
        return _Z14nvshmem_uint_g_nbst(arg_0, arg_1)
    

    @lower(uint_g, CPointer(uint32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_uint_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_uint_g_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_uint_g_nbst(shim_stream, shim_obj)


def ulong_g():
    pass
    

def _lower__Z15nvshmem_ulong_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_ulong_g_nbst(unsigned long &retval , unsigned long ** source, int* pe) {
        retval = nvshmem_ulong_g(*source, *pe);
        return 0;
    }
        """


    _Z15nvshmem_ulong_g_nbst = declare_device(
        '_Z15nvshmem_ulong_g_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_ulong_g_nbst_caller(arg_0, arg_1):
        return _Z15nvshmem_ulong_g_nbst(arg_0, arg_1)
    

    @lower(ulong_g, CPointer(uint64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_ulong_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_ulong_g_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_ulong_g_nbst(shim_stream, shim_obj)


def ulonglong_g():
    pass
    

def _lower__Z19nvshmem_ulonglong_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_ulonglong_g_nbst(unsigned long long &retval , unsigned long long ** source, int* pe) {
        retval = nvshmem_ulonglong_g(*source, *pe);
        return 0;
    }
        """


    _Z19nvshmem_ulonglong_g_nbst = declare_device(
        '_Z19nvshmem_ulonglong_g_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(int32)
        )
    )
    

    def _Z19nvshmem_ulonglong_g_nbst_caller(arg_0, arg_1):
        return _Z19nvshmem_ulonglong_g_nbst(arg_0, arg_1)
    

    @lower(ulonglong_g, CPointer(uint64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmem_ulonglong_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_ulonglong_g_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmem_ulonglong_g_nbst(shim_stream, shim_obj)


def int8_g():
    pass
    

def _lower__Z14nvshmem_int8_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_int8_g_nbst(int8_t &retval , int8_t ** source, int* pe) {
        retval = nvshmem_int8_g(*source, *pe);
        return 0;
    }
        """


    _Z14nvshmem_int8_g_nbst = declare_device(
        '_Z14nvshmem_int8_g_nbst',
        int8(
            CPointer(CPointer(int8)), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_int8_g_nbst_caller(arg_0, arg_1):
        return _Z14nvshmem_int8_g_nbst(arg_0, arg_1)
    

    @lower(int8_g, CPointer(int8), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_int8_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_int8_g_nbst_caller,
            signature(int8, CPointer(CPointer(int8)), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_int8_g_nbst(shim_stream, shim_obj)


def int16_g():
    pass
    

def _lower__Z15nvshmem_int16_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_int16_g_nbst(int16_t &retval , int16_t ** source, int* pe) {
        retval = nvshmem_int16_g(*source, *pe);
        return 0;
    }
        """


    _Z15nvshmem_int16_g_nbst = declare_device(
        '_Z15nvshmem_int16_g_nbst',
        int16(
            CPointer(CPointer(int16)), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_int16_g_nbst_caller(arg_0, arg_1):
        return _Z15nvshmem_int16_g_nbst(arg_0, arg_1)
    

    @lower(int16_g, CPointer(int16), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_int16_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_int16_g_nbst_caller,
            signature(int16, CPointer(CPointer(int16)), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_int16_g_nbst(shim_stream, shim_obj)


def int32_g():
    pass
    

def _lower__Z15nvshmem_int32_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_int32_g_nbst(int32_t &retval , int32_t ** source, int* pe) {
        retval = nvshmem_int32_g(*source, *pe);
        return 0;
    }
        """


    _Z15nvshmem_int32_g_nbst = declare_device(
        '_Z15nvshmem_int32_g_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_int32_g_nbst_caller(arg_0, arg_1):
        return _Z15nvshmem_int32_g_nbst(arg_0, arg_1)
    

    @lower(int32_g, CPointer(int32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_int32_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_int32_g_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_int32_g_nbst(shim_stream, shim_obj)


def int64_g():
    pass
    

def _lower__Z15nvshmem_int64_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_int64_g_nbst(int64_t &retval , int64_t ** source, int* pe) {
        retval = nvshmem_int64_g(*source, *pe);
        return 0;
    }
        """


    _Z15nvshmem_int64_g_nbst = declare_device(
        '_Z15nvshmem_int64_g_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_int64_g_nbst_caller(arg_0, arg_1):
        return _Z15nvshmem_int64_g_nbst(arg_0, arg_1)
    

    @lower(int64_g, CPointer(int64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_int64_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_int64_g_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_int64_g_nbst(shim_stream, shim_obj)


def uint8_g():
    pass
    

def _lower__Z15nvshmem_uint8_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_uint8_g_nbst(uint8_t &retval , uint8_t ** source, int* pe) {
        retval = nvshmem_uint8_g(*source, *pe);
        return 0;
    }
        """


    _Z15nvshmem_uint8_g_nbst = declare_device(
        '_Z15nvshmem_uint8_g_nbst',
        uint8(
            CPointer(CPointer(uint8)), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_uint8_g_nbst_caller(arg_0, arg_1):
        return _Z15nvshmem_uint8_g_nbst(arg_0, arg_1)
    

    @lower(uint8_g, CPointer(uint8), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_uint8_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_uint8_g_nbst_caller,
            signature(uint8, CPointer(CPointer(uint8)), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_uint8_g_nbst(shim_stream, shim_obj)


def uint16_g():
    pass
    

def _lower__Z16nvshmem_uint16_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_uint16_g_nbst(uint16_t &retval , uint16_t ** source, int* pe) {
        retval = nvshmem_uint16_g(*source, *pe);
        return 0;
    }
        """


    _Z16nvshmem_uint16_g_nbst = declare_device(
        '_Z16nvshmem_uint16_g_nbst',
        uint16(
            CPointer(CPointer(uint16)), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_uint16_g_nbst_caller(arg_0, arg_1):
        return _Z16nvshmem_uint16_g_nbst(arg_0, arg_1)
    

    @lower(uint16_g, CPointer(uint16), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_uint16_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_uint16_g_nbst_caller,
            signature(uint16, CPointer(CPointer(uint16)), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_uint16_g_nbst(shim_stream, shim_obj)


def uint32_g():
    pass
    

def _lower__Z16nvshmem_uint32_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_uint32_g_nbst(uint32_t &retval , uint32_t ** source, int* pe) {
        retval = nvshmem_uint32_g(*source, *pe);
        return 0;
    }
        """


    _Z16nvshmem_uint32_g_nbst = declare_device(
        '_Z16nvshmem_uint32_g_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_uint32_g_nbst_caller(arg_0, arg_1):
        return _Z16nvshmem_uint32_g_nbst(arg_0, arg_1)
    

    @lower(uint32_g, CPointer(uint32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_uint32_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_uint32_g_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_uint32_g_nbst(shim_stream, shim_obj)


def uint64_g():
    pass
    

def _lower__Z16nvshmem_uint64_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_uint64_g_nbst(uint64_t &retval , uint64_t ** source, int* pe) {
        retval = nvshmem_uint64_g(*source, *pe);
        return 0;
    }
        """


    _Z16nvshmem_uint64_g_nbst = declare_device(
        '_Z16nvshmem_uint64_g_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_uint64_g_nbst_caller(arg_0, arg_1):
        return _Z16nvshmem_uint64_g_nbst(arg_0, arg_1)
    

    @lower(uint64_g, CPointer(uint64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_uint64_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_uint64_g_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_uint64_g_nbst(shim_stream, shim_obj)


def size_g():
    pass
    

def _lower__Z14nvshmem_size_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_size_g_nbst(unsigned long &retval , unsigned long ** source, int* pe) {
        retval = nvshmem_size_g(*source, *pe);
        return 0;
    }
        """


    _Z14nvshmem_size_g_nbst = declare_device(
        '_Z14nvshmem_size_g_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_size_g_nbst_caller(arg_0, arg_1):
        return _Z14nvshmem_size_g_nbst(arg_0, arg_1)
    

    @lower(size_g, CPointer(uint64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_size_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_size_g_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_size_g_nbst(shim_stream, shim_obj)


def ptrdiff_g():
    pass
    

def _lower__Z17nvshmem_ptrdiff_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_ptrdiff_g_nbst(long &retval , long ** source, int* pe) {
        retval = nvshmem_ptrdiff_g(*source, *pe);
        return 0;
    }
        """


    _Z17nvshmem_ptrdiff_g_nbst = declare_device(
        '_Z17nvshmem_ptrdiff_g_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_ptrdiff_g_nbst_caller(arg_0, arg_1):
        return _Z17nvshmem_ptrdiff_g_nbst(arg_0, arg_1)
    

    @lower(ptrdiff_g, CPointer(int64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_ptrdiff_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_ptrdiff_g_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_ptrdiff_g_nbst(shim_stream, shim_obj)


def bfloat16_put():
    pass
    

def _lower__Z20nvshmem_bfloat16_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_bfloat16_put_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe) {
        nvshmem_bfloat16_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmem_bfloat16_put_nbst = declare_device(
        '_Z20nvshmem_bfloat16_put_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_bfloat16_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmem_bfloat16_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_put, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_bfloat16_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_bfloat16_put_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_bfloat16_put_nbst(shim_stream, shim_obj)


def half_put():
    pass
    

def _lower__Z16nvshmem_half_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_half_put_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe) {
        nvshmem_half_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z16nvshmem_half_put_nbst = declare_device(
        '_Z16nvshmem_half_put_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_half_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z16nvshmem_half_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_put, CPointer(float16), CPointer(float16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_half_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_half_put_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_half_put_nbst(shim_stream, shim_obj)


def float_put():
    pass
    

def _lower__Z17nvshmem_float_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_float_put_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe) {
        nvshmem_float_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_float_put_nbst = declare_device(
        '_Z17nvshmem_float_put_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_float_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_float_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_put, CPointer(float32), CPointer(float32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_float_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_float_put_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_float_put_nbst(shim_stream, shim_obj)


def double_put():
    pass
    

def _lower__Z18nvshmem_double_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_double_put_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe) {
        nvshmem_double_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_double_put_nbst = declare_device(
        '_Z18nvshmem_double_put_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_double_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmem_double_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_put, CPointer(float64), CPointer(float64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_double_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_double_put_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_double_put_nbst(shim_stream, shim_obj)


def char_put():
    pass
    

def _lower__Z16nvshmem_char_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_char_put_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe) {
        nvshmem_char_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z16nvshmem_char_put_nbst = declare_device(
        '_Z16nvshmem_char_put_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_char_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z16nvshmem_char_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_put, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_char_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_char_put_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_char_put_nbst(shim_stream, shim_obj)


def short_put():
    pass
    

def _lower__Z17nvshmem_short_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_short_put_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe) {
        nvshmem_short_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_short_put_nbst = declare_device(
        '_Z17nvshmem_short_put_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_short_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_short_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_put, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_short_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_short_put_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_short_put_nbst(shim_stream, shim_obj)


def schar_put():
    pass
    

def _lower__Z17nvshmem_schar_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_schar_put_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe) {
        nvshmem_schar_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_schar_put_nbst = declare_device(
        '_Z17nvshmem_schar_put_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_schar_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_schar_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_put, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_schar_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_schar_put_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_schar_put_nbst(shim_stream, shim_obj)


def int_put():
    pass
    

def _lower__Z15nvshmem_int_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_int_put_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe) {
        nvshmem_int_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z15nvshmem_int_put_nbst = declare_device(
        '_Z15nvshmem_int_put_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_int_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z15nvshmem_int_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_put, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_int_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_int_put_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_int_put_nbst(shim_stream, shim_obj)


def long_put():
    pass
    

def _lower__Z16nvshmem_long_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_long_put_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmem_long_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z16nvshmem_long_put_nbst = declare_device(
        '_Z16nvshmem_long_put_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_long_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z16nvshmem_long_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_put, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_long_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_long_put_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_long_put_nbst(shim_stream, shim_obj)


def longlong_put():
    pass
    

def _lower__Z20nvshmem_longlong_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_longlong_put_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe) {
        nvshmem_longlong_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmem_longlong_put_nbst = declare_device(
        '_Z20nvshmem_longlong_put_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_longlong_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmem_longlong_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_put, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_longlong_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_longlong_put_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_longlong_put_nbst(shim_stream, shim_obj)


def uchar_put():
    pass
    

def _lower__Z17nvshmem_uchar_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_uchar_put_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe) {
        nvshmem_uchar_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_uchar_put_nbst = declare_device(
        '_Z17nvshmem_uchar_put_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_uchar_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_uchar_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_put, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_uchar_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_uchar_put_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_uchar_put_nbst(shim_stream, shim_obj)


def ushort_put():
    pass
    

def _lower__Z18nvshmem_ushort_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_ushort_put_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe) {
        nvshmem_ushort_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_ushort_put_nbst = declare_device(
        '_Z18nvshmem_ushort_put_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_ushort_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmem_ushort_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_put, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_ushort_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_ushort_put_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_ushort_put_nbst(shim_stream, shim_obj)


def uint_put():
    pass
    

def _lower__Z16nvshmem_uint_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_uint_put_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z16nvshmem_uint_put_nbst = declare_device(
        '_Z16nvshmem_uint_put_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_uint_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z16nvshmem_uint_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_put, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_uint_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_uint_put_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_uint_put_nbst(shim_stream, shim_obj)


def ulong_put():
    pass
    

def _lower__Z17nvshmem_ulong_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_ulong_put_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmem_ulong_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_ulong_put_nbst = declare_device(
        '_Z17nvshmem_ulong_put_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_ulong_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_ulong_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_put, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_ulong_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_ulong_put_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_ulong_put_nbst(shim_stream, shim_obj)


def ulonglong_put():
    pass
    

def _lower__Z21nvshmem_ulonglong_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_ulonglong_put_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe) {
        nvshmem_ulonglong_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_ulonglong_put_nbst = declare_device(
        '_Z21nvshmem_ulonglong_put_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_ulonglong_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_ulonglong_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_put, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_ulonglong_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_ulonglong_put_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_ulonglong_put_nbst(shim_stream, shim_obj)


def int8_put():
    pass
    

def _lower__Z16nvshmem_int8_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_int8_put_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_int8_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z16nvshmem_int8_put_nbst = declare_device(
        '_Z16nvshmem_int8_put_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_int8_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z16nvshmem_int8_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_put, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_int8_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_int8_put_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_int8_put_nbst(shim_stream, shim_obj)


def int16_put():
    pass
    

def _lower__Z17nvshmem_int16_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_int16_put_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_int16_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_int16_put_nbst = declare_device(
        '_Z17nvshmem_int16_put_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_int16_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_int16_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_put, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_int16_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_int16_put_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_int16_put_nbst(shim_stream, shim_obj)


def int32_put():
    pass
    

def _lower__Z17nvshmem_int32_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_int32_put_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_int32_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_int32_put_nbst = declare_device(
        '_Z17nvshmem_int32_put_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_int32_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_int32_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_put, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_int32_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_int32_put_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_int32_put_nbst(shim_stream, shim_obj)


def int64_put():
    pass
    

def _lower__Z17nvshmem_int64_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_int64_put_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_int64_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_int64_put_nbst = declare_device(
        '_Z17nvshmem_int64_put_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_int64_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_int64_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_put, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_int64_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_int64_put_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_int64_put_nbst(shim_stream, shim_obj)


def uint8_put():
    pass
    

def _lower__Z17nvshmem_uint8_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_uint8_put_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint8_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_uint8_put_nbst = declare_device(
        '_Z17nvshmem_uint8_put_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_uint8_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_uint8_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_put, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_uint8_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_uint8_put_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_uint8_put_nbst(shim_stream, shim_obj)


def uint16_put():
    pass
    

def _lower__Z18nvshmem_uint16_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_uint16_put_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint16_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_uint16_put_nbst = declare_device(
        '_Z18nvshmem_uint16_put_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_uint16_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmem_uint16_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_put, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_uint16_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_uint16_put_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_uint16_put_nbst(shim_stream, shim_obj)


def uint32_put():
    pass
    

def _lower__Z18nvshmem_uint32_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_uint32_put_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint32_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_uint32_put_nbst = declare_device(
        '_Z18nvshmem_uint32_put_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_uint32_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmem_uint32_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_put, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_uint32_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_uint32_put_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_uint32_put_nbst(shim_stream, shim_obj)


def uint64_put():
    pass
    

def _lower__Z18nvshmem_uint64_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_uint64_put_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint64_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_uint64_put_nbst = declare_device(
        '_Z18nvshmem_uint64_put_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_uint64_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmem_uint64_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_put, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_uint64_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_uint64_put_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_uint64_put_nbst(shim_stream, shim_obj)


def size_put():
    pass
    

def _lower__Z16nvshmem_size_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_size_put_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmem_size_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z16nvshmem_size_put_nbst = declare_device(
        '_Z16nvshmem_size_put_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_size_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z16nvshmem_size_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_put, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_size_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_size_put_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_size_put_nbst(shim_stream, shim_obj)


def ptrdiff_put():
    pass
    

def _lower__Z19nvshmem_ptrdiff_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_ptrdiff_put_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmem_ptrdiff_put(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmem_ptrdiff_put_nbst = declare_device(
        '_Z19nvshmem_ptrdiff_put_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmem_ptrdiff_put_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmem_ptrdiff_put_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ptrdiff_put, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmem_ptrdiff_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_ptrdiff_put_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmem_ptrdiff_put_nbst(shim_stream, shim_obj)


def bfloat16_put_signal():
    pass
    

def _lower__Z27nvshmem_bfloat16_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_bfloat16_put_signal_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_bfloat16_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z27nvshmem_bfloat16_put_signal_nbst = declare_device(
        '_Z27nvshmem_bfloat16_put_signal_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmem_bfloat16_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z27nvshmem_bfloat16_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(bfloat16_put_signal, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmem_bfloat16_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_bfloat16_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmem_bfloat16_put_signal_nbst(shim_stream, shim_obj)


def half_put_signal():
    pass
    

def _lower__Z23nvshmem_half_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_half_put_signal_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_half_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z23nvshmem_half_put_signal_nbst = declare_device(
        '_Z23nvshmem_half_put_signal_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_half_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z23nvshmem_half_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(half_put_signal, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_half_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_half_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_half_put_signal_nbst(shim_stream, shim_obj)


def float_put_signal():
    pass
    

def _lower__Z24nvshmem_float_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_float_put_signal_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_float_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z24nvshmem_float_put_signal_nbst = declare_device(
        '_Z24nvshmem_float_put_signal_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_float_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z24nvshmem_float_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(float_put_signal, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_float_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_float_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_float_put_signal_nbst(shim_stream, shim_obj)


def double_put_signal():
    pass
    

def _lower__Z25nvshmem_double_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_double_put_signal_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_double_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z25nvshmem_double_put_signal_nbst = declare_device(
        '_Z25nvshmem_double_put_signal_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_double_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z25nvshmem_double_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(double_put_signal, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_double_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_double_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_double_put_signal_nbst(shim_stream, shim_obj)


def char_put_signal():
    pass
    

def _lower__Z23nvshmem_char_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_char_put_signal_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_char_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z23nvshmem_char_put_signal_nbst = declare_device(
        '_Z23nvshmem_char_put_signal_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_char_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z23nvshmem_char_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(char_put_signal, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_char_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_char_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_char_put_signal_nbst(shim_stream, shim_obj)


def short_put_signal():
    pass
    

def _lower__Z24nvshmem_short_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_short_put_signal_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_short_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z24nvshmem_short_put_signal_nbst = declare_device(
        '_Z24nvshmem_short_put_signal_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_short_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z24nvshmem_short_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(short_put_signal, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_short_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_short_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_short_put_signal_nbst(shim_stream, shim_obj)


def schar_put_signal():
    pass
    

def _lower__Z24nvshmem_schar_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_schar_put_signal_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_schar_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z24nvshmem_schar_put_signal_nbst = declare_device(
        '_Z24nvshmem_schar_put_signal_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_schar_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z24nvshmem_schar_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(schar_put_signal, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_schar_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_schar_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_schar_put_signal_nbst(shim_stream, shim_obj)


def int_put_signal():
    pass
    

def _lower__Z22nvshmem_int_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_int_put_signal_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_int_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z22nvshmem_int_put_signal_nbst = declare_device(
        '_Z22nvshmem_int_put_signal_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_int_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z22nvshmem_int_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int_put_signal, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmem_int_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_int_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_int_put_signal_nbst(shim_stream, shim_obj)


def long_put_signal():
    pass
    

def _lower__Z23nvshmem_long_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_long_put_signal_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_long_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z23nvshmem_long_put_signal_nbst = declare_device(
        '_Z23nvshmem_long_put_signal_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_long_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z23nvshmem_long_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(long_put_signal, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_long_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_long_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_long_put_signal_nbst(shim_stream, shim_obj)


def longlong_put_signal():
    pass
    

def _lower__Z27nvshmem_longlong_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_longlong_put_signal_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_longlong_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z27nvshmem_longlong_put_signal_nbst = declare_device(
        '_Z27nvshmem_longlong_put_signal_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmem_longlong_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z27nvshmem_longlong_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(longlong_put_signal, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmem_longlong_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_longlong_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmem_longlong_put_signal_nbst(shim_stream, shim_obj)


def uchar_put_signal():
    pass
    

def _lower__Z24nvshmem_uchar_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_uchar_put_signal_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_uchar_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z24nvshmem_uchar_put_signal_nbst = declare_device(
        '_Z24nvshmem_uchar_put_signal_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_uchar_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z24nvshmem_uchar_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uchar_put_signal, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_uchar_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_uchar_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_uchar_put_signal_nbst(shim_stream, shim_obj)


def ushort_put_signal():
    pass
    

def _lower__Z25nvshmem_ushort_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_ushort_put_signal_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_ushort_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z25nvshmem_ushort_put_signal_nbst = declare_device(
        '_Z25nvshmem_ushort_put_signal_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_ushort_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z25nvshmem_ushort_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ushort_put_signal, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_ushort_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_ushort_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_ushort_put_signal_nbst(shim_stream, shim_obj)


def uint_put_signal():
    pass
    

def _lower__Z23nvshmem_uint_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_uint_put_signal_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_uint_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z23nvshmem_uint_put_signal_nbst = declare_device(
        '_Z23nvshmem_uint_put_signal_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_uint_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z23nvshmem_uint_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint_put_signal, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_uint_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_uint_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_uint_put_signal_nbst(shim_stream, shim_obj)


def ulong_put_signal():
    pass
    

def _lower__Z24nvshmem_ulong_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_ulong_put_signal_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_ulong_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z24nvshmem_ulong_put_signal_nbst = declare_device(
        '_Z24nvshmem_ulong_put_signal_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_ulong_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z24nvshmem_ulong_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ulong_put_signal, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_ulong_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_ulong_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_ulong_put_signal_nbst(shim_stream, shim_obj)


def ulonglong_put_signal():
    pass
    

def _lower__Z28nvshmem_ulonglong_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_ulonglong_put_signal_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_ulonglong_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z28nvshmem_ulonglong_put_signal_nbst = declare_device(
        '_Z28nvshmem_ulonglong_put_signal_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_ulonglong_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z28nvshmem_ulonglong_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ulonglong_put_signal, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_ulonglong_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_ulonglong_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_ulonglong_put_signal_nbst(shim_stream, shim_obj)


def int8_put_signal():
    pass
    

def _lower__Z23nvshmem_int8_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_int8_put_signal_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_int8_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z23nvshmem_int8_put_signal_nbst = declare_device(
        '_Z23nvshmem_int8_put_signal_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_int8_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z23nvshmem_int8_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int8_put_signal, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_int8_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_int8_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_int8_put_signal_nbst(shim_stream, shim_obj)


def int16_put_signal():
    pass
    

def _lower__Z24nvshmem_int16_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_int16_put_signal_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_int16_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z24nvshmem_int16_put_signal_nbst = declare_device(
        '_Z24nvshmem_int16_put_signal_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_int16_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z24nvshmem_int16_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int16_put_signal, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_int16_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_int16_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_int16_put_signal_nbst(shim_stream, shim_obj)


def int32_put_signal():
    pass
    

def _lower__Z24nvshmem_int32_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_int32_put_signal_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_int32_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z24nvshmem_int32_put_signal_nbst = declare_device(
        '_Z24nvshmem_int32_put_signal_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_int32_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z24nvshmem_int32_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int32_put_signal, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_int32_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_int32_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_int32_put_signal_nbst(shim_stream, shim_obj)


def int64_put_signal():
    pass
    

def _lower__Z24nvshmem_int64_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_int64_put_signal_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_int64_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z24nvshmem_int64_put_signal_nbst = declare_device(
        '_Z24nvshmem_int64_put_signal_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_int64_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z24nvshmem_int64_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int64_put_signal, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_int64_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_int64_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_int64_put_signal_nbst(shim_stream, shim_obj)


def uint8_put_signal():
    pass
    

def _lower__Z24nvshmem_uint8_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_uint8_put_signal_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_uint8_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z24nvshmem_uint8_put_signal_nbst = declare_device(
        '_Z24nvshmem_uint8_put_signal_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_uint8_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z24nvshmem_uint8_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint8_put_signal, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_uint8_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_uint8_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_uint8_put_signal_nbst(shim_stream, shim_obj)


def uint16_put_signal():
    pass
    

def _lower__Z25nvshmem_uint16_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_uint16_put_signal_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_uint16_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z25nvshmem_uint16_put_signal_nbst = declare_device(
        '_Z25nvshmem_uint16_put_signal_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_uint16_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z25nvshmem_uint16_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint16_put_signal, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_uint16_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_uint16_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_uint16_put_signal_nbst(shim_stream, shim_obj)


def uint32_put_signal():
    pass
    

def _lower__Z25nvshmem_uint32_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_uint32_put_signal_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_uint32_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z25nvshmem_uint32_put_signal_nbst = declare_device(
        '_Z25nvshmem_uint32_put_signal_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_uint32_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z25nvshmem_uint32_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint32_put_signal, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_uint32_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_uint32_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_uint32_put_signal_nbst(shim_stream, shim_obj)


def uint64_put_signal():
    pass
    

def _lower__Z25nvshmem_uint64_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_uint64_put_signal_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_uint64_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z25nvshmem_uint64_put_signal_nbst = declare_device(
        '_Z25nvshmem_uint64_put_signal_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_uint64_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z25nvshmem_uint64_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint64_put_signal, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_uint64_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_uint64_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_uint64_put_signal_nbst(shim_stream, shim_obj)


def size_put_signal():
    pass
    

def _lower__Z23nvshmem_size_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_size_put_signal_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_size_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z23nvshmem_size_put_signal_nbst = declare_device(
        '_Z23nvshmem_size_put_signal_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_size_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z23nvshmem_size_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(size_put_signal, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_size_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_size_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_size_put_signal_nbst(shim_stream, shim_obj)


def ptrdiff_put_signal():
    pass
    

def _lower__Z26nvshmem_ptrdiff_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmem_ptrdiff_put_signal_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_ptrdiff_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z26nvshmem_ptrdiff_put_signal_nbst = declare_device(
        '_Z26nvshmem_ptrdiff_put_signal_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmem_ptrdiff_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z26nvshmem_ptrdiff_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ptrdiff_put_signal, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmem_ptrdiff_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmem_ptrdiff_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmem_ptrdiff_put_signal_nbst(shim_stream, shim_obj)


def bfloat16_get():
    pass
    

def _lower__Z20nvshmem_bfloat16_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_bfloat16_get_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe) {
        nvshmem_bfloat16_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmem_bfloat16_get_nbst = declare_device(
        '_Z20nvshmem_bfloat16_get_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_bfloat16_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmem_bfloat16_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_get, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_bfloat16_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_bfloat16_get_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_bfloat16_get_nbst(shim_stream, shim_obj)


def half_get():
    pass
    

def _lower__Z16nvshmem_half_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_half_get_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe) {
        nvshmem_half_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z16nvshmem_half_get_nbst = declare_device(
        '_Z16nvshmem_half_get_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_half_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z16nvshmem_half_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_get, CPointer(float16), CPointer(float16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_half_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_half_get_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_half_get_nbst(shim_stream, shim_obj)


def float_get():
    pass
    

def _lower__Z17nvshmem_float_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_float_get_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe) {
        nvshmem_float_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_float_get_nbst = declare_device(
        '_Z17nvshmem_float_get_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_float_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_float_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_get, CPointer(float32), CPointer(float32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_float_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_float_get_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_float_get_nbst(shim_stream, shim_obj)


def double_get():
    pass
    

def _lower__Z18nvshmem_double_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_double_get_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe) {
        nvshmem_double_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_double_get_nbst = declare_device(
        '_Z18nvshmem_double_get_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_double_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmem_double_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_get, CPointer(float64), CPointer(float64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_double_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_double_get_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_double_get_nbst(shim_stream, shim_obj)


def char_get():
    pass
    

def _lower__Z16nvshmem_char_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_char_get_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe) {
        nvshmem_char_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z16nvshmem_char_get_nbst = declare_device(
        '_Z16nvshmem_char_get_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_char_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z16nvshmem_char_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_get, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_char_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_char_get_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_char_get_nbst(shim_stream, shim_obj)


def short_get():
    pass
    

def _lower__Z17nvshmem_short_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_short_get_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe) {
        nvshmem_short_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_short_get_nbst = declare_device(
        '_Z17nvshmem_short_get_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_short_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_short_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_get, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_short_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_short_get_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_short_get_nbst(shim_stream, shim_obj)


def schar_get():
    pass
    

def _lower__Z17nvshmem_schar_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_schar_get_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe) {
        nvshmem_schar_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_schar_get_nbst = declare_device(
        '_Z17nvshmem_schar_get_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_schar_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_schar_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_get, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_schar_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_schar_get_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_schar_get_nbst(shim_stream, shim_obj)


def int_get():
    pass
    

def _lower__Z15nvshmem_int_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_int_get_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe) {
        nvshmem_int_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z15nvshmem_int_get_nbst = declare_device(
        '_Z15nvshmem_int_get_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_int_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z15nvshmem_int_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_get, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_int_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_int_get_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_int_get_nbst(shim_stream, shim_obj)


def long_get():
    pass
    

def _lower__Z16nvshmem_long_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_long_get_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmem_long_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z16nvshmem_long_get_nbst = declare_device(
        '_Z16nvshmem_long_get_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_long_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z16nvshmem_long_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_get, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_long_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_long_get_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_long_get_nbst(shim_stream, shim_obj)


def longlong_get():
    pass
    

def _lower__Z20nvshmem_longlong_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_longlong_get_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe) {
        nvshmem_longlong_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmem_longlong_get_nbst = declare_device(
        '_Z20nvshmem_longlong_get_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_longlong_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmem_longlong_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_get, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_longlong_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_longlong_get_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_longlong_get_nbst(shim_stream, shim_obj)


def uchar_get():
    pass
    

def _lower__Z17nvshmem_uchar_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_uchar_get_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe) {
        nvshmem_uchar_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_uchar_get_nbst = declare_device(
        '_Z17nvshmem_uchar_get_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_uchar_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_uchar_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_get, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_uchar_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_uchar_get_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_uchar_get_nbst(shim_stream, shim_obj)


def ushort_get():
    pass
    

def _lower__Z18nvshmem_ushort_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_ushort_get_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe) {
        nvshmem_ushort_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_ushort_get_nbst = declare_device(
        '_Z18nvshmem_ushort_get_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_ushort_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmem_ushort_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_get, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_ushort_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_ushort_get_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_ushort_get_nbst(shim_stream, shim_obj)


def uint_get():
    pass
    

def _lower__Z16nvshmem_uint_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_uint_get_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z16nvshmem_uint_get_nbst = declare_device(
        '_Z16nvshmem_uint_get_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_uint_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z16nvshmem_uint_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_get, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_uint_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_uint_get_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_uint_get_nbst(shim_stream, shim_obj)


def ulong_get():
    pass
    

def _lower__Z17nvshmem_ulong_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_ulong_get_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmem_ulong_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_ulong_get_nbst = declare_device(
        '_Z17nvshmem_ulong_get_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_ulong_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_ulong_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_get, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_ulong_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_ulong_get_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_ulong_get_nbst(shim_stream, shim_obj)


def ulonglong_get():
    pass
    

def _lower__Z21nvshmem_ulonglong_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_ulonglong_get_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe) {
        nvshmem_ulonglong_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_ulonglong_get_nbst = declare_device(
        '_Z21nvshmem_ulonglong_get_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_ulonglong_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_ulonglong_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_get, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_ulonglong_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_ulonglong_get_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_ulonglong_get_nbst(shim_stream, shim_obj)


def int8_get():
    pass
    

def _lower__Z16nvshmem_int8_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_int8_get_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_int8_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z16nvshmem_int8_get_nbst = declare_device(
        '_Z16nvshmem_int8_get_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_int8_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z16nvshmem_int8_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_get, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_int8_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_int8_get_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_int8_get_nbst(shim_stream, shim_obj)


def int16_get():
    pass
    

def _lower__Z17nvshmem_int16_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_int16_get_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_int16_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_int16_get_nbst = declare_device(
        '_Z17nvshmem_int16_get_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_int16_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_int16_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_get, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_int16_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_int16_get_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_int16_get_nbst(shim_stream, shim_obj)


def int32_get():
    pass
    

def _lower__Z17nvshmem_int32_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_int32_get_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_int32_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_int32_get_nbst = declare_device(
        '_Z17nvshmem_int32_get_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_int32_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_int32_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_get, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_int32_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_int32_get_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_int32_get_nbst(shim_stream, shim_obj)


def int64_get():
    pass
    

def _lower__Z17nvshmem_int64_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_int64_get_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_int64_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_int64_get_nbst = declare_device(
        '_Z17nvshmem_int64_get_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_int64_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_int64_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_get, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_int64_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_int64_get_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_int64_get_nbst(shim_stream, shim_obj)


def uint8_get():
    pass
    

def _lower__Z17nvshmem_uint8_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_uint8_get_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint8_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_uint8_get_nbst = declare_device(
        '_Z17nvshmem_uint8_get_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_uint8_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_uint8_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_get, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_uint8_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_uint8_get_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_uint8_get_nbst(shim_stream, shim_obj)


def uint16_get():
    pass
    

def _lower__Z18nvshmem_uint16_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_uint16_get_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint16_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_uint16_get_nbst = declare_device(
        '_Z18nvshmem_uint16_get_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_uint16_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmem_uint16_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_get, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_uint16_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_uint16_get_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_uint16_get_nbst(shim_stream, shim_obj)


def uint32_get():
    pass
    

def _lower__Z18nvshmem_uint32_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_uint32_get_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint32_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_uint32_get_nbst = declare_device(
        '_Z18nvshmem_uint32_get_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_uint32_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmem_uint32_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_get, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_uint32_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_uint32_get_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_uint32_get_nbst(shim_stream, shim_obj)


def uint64_get():
    pass
    

def _lower__Z18nvshmem_uint64_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_uint64_get_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint64_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_uint64_get_nbst = declare_device(
        '_Z18nvshmem_uint64_get_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_uint64_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmem_uint64_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_get, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_uint64_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_uint64_get_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_uint64_get_nbst(shim_stream, shim_obj)


def size_get():
    pass
    

def _lower__Z16nvshmem_size_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_size_get_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmem_size_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z16nvshmem_size_get_nbst = declare_device(
        '_Z16nvshmem_size_get_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_size_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z16nvshmem_size_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_get, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_size_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_size_get_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_size_get_nbst(shim_stream, shim_obj)


def ptrdiff_get():
    pass
    

def _lower__Z19nvshmem_ptrdiff_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_ptrdiff_get_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmem_ptrdiff_get(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmem_ptrdiff_get_nbst = declare_device(
        '_Z19nvshmem_ptrdiff_get_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmem_ptrdiff_get_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmem_ptrdiff_get_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ptrdiff_get, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmem_ptrdiff_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_ptrdiff_get_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmem_ptrdiff_get_nbst(shim_stream, shim_obj)


def put8():
    pass
    

def _lower__Z12nvshmem_put8_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z12nvshmem_put8_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_put8(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z12nvshmem_put8_nbst = declare_device(
        '_Z12nvshmem_put8_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z12nvshmem_put8_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z12nvshmem_put8_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put8, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z12nvshmem_put8_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z12nvshmem_put8_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z12nvshmem_put8_nbst(shim_stream, shim_obj)


def put16():
    pass
    

def _lower__Z13nvshmem_put16_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z13nvshmem_put16_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_put16(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z13nvshmem_put16_nbst = declare_device(
        '_Z13nvshmem_put16_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z13nvshmem_put16_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z13nvshmem_put16_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put16, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z13nvshmem_put16_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z13nvshmem_put16_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z13nvshmem_put16_nbst(shim_stream, shim_obj)


def put32():
    pass
    

def _lower__Z13nvshmem_put32_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z13nvshmem_put32_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_put32(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z13nvshmem_put32_nbst = declare_device(
        '_Z13nvshmem_put32_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z13nvshmem_put32_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z13nvshmem_put32_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put32, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z13nvshmem_put32_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z13nvshmem_put32_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z13nvshmem_put32_nbst(shim_stream, shim_obj)


def put64():
    pass
    

def _lower__Z13nvshmem_put64_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z13nvshmem_put64_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_put64(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z13nvshmem_put64_nbst = declare_device(
        '_Z13nvshmem_put64_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z13nvshmem_put64_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z13nvshmem_put64_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put64, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z13nvshmem_put64_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z13nvshmem_put64_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z13nvshmem_put64_nbst(shim_stream, shim_obj)


def put128():
    pass
    

def _lower__Z14nvshmem_put128_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_put128_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_put128(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z14nvshmem_put128_nbst = declare_device(
        '_Z14nvshmem_put128_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_put128_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z14nvshmem_put128_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put128, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_put128_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_put128_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_put128_nbst(shim_stream, shim_obj)


def putmem_signal():
    pass
    

def _lower__Z21nvshmem_putmem_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_putmem_signal_nbst(int &retval , void ** dest, void ** source, unsigned long* bytes, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_putmem_signal(*dest, *source, *bytes, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z21nvshmem_putmem_signal_nbst = declare_device(
        '_Z21nvshmem_putmem_signal_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_putmem_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z21nvshmem_putmem_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(putmem_signal, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_putmem_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_putmem_signal_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_putmem_signal_nbst(shim_stream, shim_obj)


def put8_signal():
    pass
    

def _lower__Z19nvshmem_put8_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_put8_signal_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_put8_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z19nvshmem_put8_signal_nbst = declare_device(
        '_Z19nvshmem_put8_signal_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmem_put8_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z19nvshmem_put8_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put8_signal, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmem_put8_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_put8_signal_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmem_put8_signal_nbst(shim_stream, shim_obj)


def put16_signal():
    pass
    

def _lower__Z20nvshmem_put16_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_put16_signal_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_put16_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z20nvshmem_put16_signal_nbst = declare_device(
        '_Z20nvshmem_put16_signal_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_put16_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z20nvshmem_put16_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put16_signal, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_put16_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_put16_signal_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_put16_signal_nbst(shim_stream, shim_obj)


def put32_signal():
    pass
    

def _lower__Z20nvshmem_put32_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_put32_signal_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_put32_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z20nvshmem_put32_signal_nbst = declare_device(
        '_Z20nvshmem_put32_signal_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_put32_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z20nvshmem_put32_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put32_signal, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_put32_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_put32_signal_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_put32_signal_nbst(shim_stream, shim_obj)


def put64_signal():
    pass
    

def _lower__Z20nvshmem_put64_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_put64_signal_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_put64_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z20nvshmem_put64_signal_nbst = declare_device(
        '_Z20nvshmem_put64_signal_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_put64_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z20nvshmem_put64_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put64_signal, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_put64_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_put64_signal_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_put64_signal_nbst(shim_stream, shim_obj)


def put128_signal():
    pass
    

def _lower__Z21nvshmem_put128_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_put128_signal_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_put128_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z21nvshmem_put128_signal_nbst = declare_device(
        '_Z21nvshmem_put128_signal_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_put128_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z21nvshmem_put128_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put128_signal, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_put128_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_put128_signal_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_put128_signal_nbst(shim_stream, shim_obj)


def get8():
    pass
    

def _lower__Z12nvshmem_get8_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z12nvshmem_get8_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_get8(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z12nvshmem_get8_nbst = declare_device(
        '_Z12nvshmem_get8_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z12nvshmem_get8_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z12nvshmem_get8_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get8, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z12nvshmem_get8_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z12nvshmem_get8_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z12nvshmem_get8_nbst(shim_stream, shim_obj)


def get16():
    pass
    

def _lower__Z13nvshmem_get16_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z13nvshmem_get16_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_get16(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z13nvshmem_get16_nbst = declare_device(
        '_Z13nvshmem_get16_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z13nvshmem_get16_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z13nvshmem_get16_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get16, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z13nvshmem_get16_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z13nvshmem_get16_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z13nvshmem_get16_nbst(shim_stream, shim_obj)


def get32():
    pass
    

def _lower__Z13nvshmem_get32_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z13nvshmem_get32_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_get32(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z13nvshmem_get32_nbst = declare_device(
        '_Z13nvshmem_get32_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z13nvshmem_get32_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z13nvshmem_get32_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get32, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z13nvshmem_get32_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z13nvshmem_get32_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z13nvshmem_get32_nbst(shim_stream, shim_obj)


def get64():
    pass
    

def _lower__Z13nvshmem_get64_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z13nvshmem_get64_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_get64(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z13nvshmem_get64_nbst = declare_device(
        '_Z13nvshmem_get64_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z13nvshmem_get64_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z13nvshmem_get64_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get64, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z13nvshmem_get64_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z13nvshmem_get64_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z13nvshmem_get64_nbst(shim_stream, shim_obj)


def get128():
    pass
    

def _lower__Z14nvshmem_get128_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_get128_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_get128(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z14nvshmem_get128_nbst = declare_device(
        '_Z14nvshmem_get128_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_get128_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z14nvshmem_get128_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get128, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_get128_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_get128_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_get128_nbst(shim_stream, shim_obj)


def putmem():
    pass
    

def _lower__Z14nvshmem_putmem_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_putmem_nbst(int &retval , void ** dest, void ** source, unsigned long* bytes, int* pe) {
        nvshmem_putmem(*dest, *source, *bytes, *pe);
        return 0;
    }
        """


    _Z14nvshmem_putmem_nbst = declare_device(
        '_Z14nvshmem_putmem_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_putmem_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z14nvshmem_putmem_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(putmem, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_putmem_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_putmem_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_putmem_nbst(shim_stream, shim_obj)


def getmem():
    pass
    

def _lower__Z14nvshmem_getmem_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_getmem_nbst(int &retval , void ** dest, void ** source, unsigned long* bytes, int* pe) {
        nvshmem_getmem(*dest, *source, *bytes, *pe);
        return 0;
    }
        """


    _Z14nvshmem_getmem_nbst = declare_device(
        '_Z14nvshmem_getmem_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_getmem_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z14nvshmem_getmem_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(getmem, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_getmem_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_getmem_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_getmem_nbst(shim_stream, shim_obj)


def bfloat16_put_nbi():
    pass
    

def _lower__Z24nvshmem_bfloat16_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_bfloat16_put_nbi_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe) {
        nvshmem_bfloat16_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmem_bfloat16_put_nbi_nbst = declare_device(
        '_Z24nvshmem_bfloat16_put_nbi_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_bfloat16_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmem_bfloat16_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_put_nbi, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_bfloat16_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_bfloat16_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_bfloat16_put_nbi_nbst(shim_stream, shim_obj)


def half_put_nbi():
    pass
    

def _lower__Z20nvshmem_half_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_half_put_nbi_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe) {
        nvshmem_half_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmem_half_put_nbi_nbst = declare_device(
        '_Z20nvshmem_half_put_nbi_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_half_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmem_half_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_put_nbi, CPointer(float16), CPointer(float16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_half_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_half_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_half_put_nbi_nbst(shim_stream, shim_obj)


def float_put_nbi():
    pass
    

def _lower__Z21nvshmem_float_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_float_put_nbi_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe) {
        nvshmem_float_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_float_put_nbi_nbst = declare_device(
        '_Z21nvshmem_float_put_nbi_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_float_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_float_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_put_nbi, CPointer(float32), CPointer(float32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_float_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_float_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_float_put_nbi_nbst(shim_stream, shim_obj)


def double_put_nbi():
    pass
    

def _lower__Z22nvshmem_double_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_double_put_nbi_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe) {
        nvshmem_double_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmem_double_put_nbi_nbst = declare_device(
        '_Z22nvshmem_double_put_nbi_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_double_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmem_double_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_put_nbi, CPointer(float64), CPointer(float64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmem_double_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_double_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_double_put_nbi_nbst(shim_stream, shim_obj)


def char_put_nbi():
    pass
    

def _lower__Z20nvshmem_char_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_char_put_nbi_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe) {
        nvshmem_char_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmem_char_put_nbi_nbst = declare_device(
        '_Z20nvshmem_char_put_nbi_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_char_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmem_char_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_put_nbi, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_char_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_char_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_char_put_nbi_nbst(shim_stream, shim_obj)


def short_put_nbi():
    pass
    

def _lower__Z21nvshmem_short_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_short_put_nbi_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe) {
        nvshmem_short_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_short_put_nbi_nbst = declare_device(
        '_Z21nvshmem_short_put_nbi_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_short_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_short_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_put_nbi, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_short_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_short_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_short_put_nbi_nbst(shim_stream, shim_obj)


def schar_put_nbi():
    pass
    

def _lower__Z21nvshmem_schar_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_schar_put_nbi_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe) {
        nvshmem_schar_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_schar_put_nbi_nbst = declare_device(
        '_Z21nvshmem_schar_put_nbi_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_schar_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_schar_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_put_nbi, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_schar_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_schar_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_schar_put_nbi_nbst(shim_stream, shim_obj)


def int_put_nbi():
    pass
    

def _lower__Z19nvshmem_int_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_int_put_nbi_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe) {
        nvshmem_int_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmem_int_put_nbi_nbst = declare_device(
        '_Z19nvshmem_int_put_nbi_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmem_int_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmem_int_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_put_nbi, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmem_int_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_int_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmem_int_put_nbi_nbst(shim_stream, shim_obj)


def long_put_nbi():
    pass
    

def _lower__Z20nvshmem_long_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_long_put_nbi_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmem_long_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmem_long_put_nbi_nbst = declare_device(
        '_Z20nvshmem_long_put_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_long_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmem_long_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_put_nbi, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_long_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_long_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_long_put_nbi_nbst(shim_stream, shim_obj)


def longlong_put_nbi():
    pass
    

def _lower__Z24nvshmem_longlong_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_longlong_put_nbi_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe) {
        nvshmem_longlong_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmem_longlong_put_nbi_nbst = declare_device(
        '_Z24nvshmem_longlong_put_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_longlong_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmem_longlong_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_put_nbi, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_longlong_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_longlong_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_longlong_put_nbi_nbst(shim_stream, shim_obj)


def uchar_put_nbi():
    pass
    

def _lower__Z21nvshmem_uchar_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_uchar_put_nbi_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe) {
        nvshmem_uchar_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_uchar_put_nbi_nbst = declare_device(
        '_Z21nvshmem_uchar_put_nbi_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_uchar_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_uchar_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_put_nbi, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_uchar_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_uchar_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_uchar_put_nbi_nbst(shim_stream, shim_obj)


def ushort_put_nbi():
    pass
    

def _lower__Z22nvshmem_ushort_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_ushort_put_nbi_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe) {
        nvshmem_ushort_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmem_ushort_put_nbi_nbst = declare_device(
        '_Z22nvshmem_ushort_put_nbi_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_ushort_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmem_ushort_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_put_nbi, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmem_ushort_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_ushort_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_ushort_put_nbi_nbst(shim_stream, shim_obj)


def uint_put_nbi():
    pass
    

def _lower__Z20nvshmem_uint_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_uint_put_nbi_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmem_uint_put_nbi_nbst = declare_device(
        '_Z20nvshmem_uint_put_nbi_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_uint_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmem_uint_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_put_nbi, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_uint_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_uint_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_uint_put_nbi_nbst(shim_stream, shim_obj)


def ulong_put_nbi():
    pass
    

def _lower__Z21nvshmem_ulong_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_ulong_put_nbi_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmem_ulong_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_ulong_put_nbi_nbst = declare_device(
        '_Z21nvshmem_ulong_put_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_ulong_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_ulong_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_put_nbi, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_ulong_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_ulong_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_ulong_put_nbi_nbst(shim_stream, shim_obj)


def ulonglong_put_nbi():
    pass
    

def _lower__Z25nvshmem_ulonglong_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_ulonglong_put_nbi_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe) {
        nvshmem_ulonglong_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmem_ulonglong_put_nbi_nbst = declare_device(
        '_Z25nvshmem_ulonglong_put_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_ulonglong_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmem_ulonglong_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_put_nbi, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_ulonglong_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_ulonglong_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_ulonglong_put_nbi_nbst(shim_stream, shim_obj)


def int8_put_nbi():
    pass
    

def _lower__Z20nvshmem_int8_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_int8_put_nbi_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_int8_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmem_int8_put_nbi_nbst = declare_device(
        '_Z20nvshmem_int8_put_nbi_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_int8_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmem_int8_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_put_nbi, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_int8_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_int8_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_int8_put_nbi_nbst(shim_stream, shim_obj)


def int16_put_nbi():
    pass
    

def _lower__Z21nvshmem_int16_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_int16_put_nbi_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_int16_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_int16_put_nbi_nbst = declare_device(
        '_Z21nvshmem_int16_put_nbi_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_int16_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_int16_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_put_nbi, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_int16_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_int16_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_int16_put_nbi_nbst(shim_stream, shim_obj)


def int32_put_nbi():
    pass
    

def _lower__Z21nvshmem_int32_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_int32_put_nbi_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_int32_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_int32_put_nbi_nbst = declare_device(
        '_Z21nvshmem_int32_put_nbi_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_int32_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_int32_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_put_nbi, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_int32_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_int32_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_int32_put_nbi_nbst(shim_stream, shim_obj)


def int64_put_nbi():
    pass
    

def _lower__Z21nvshmem_int64_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_int64_put_nbi_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_int64_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_int64_put_nbi_nbst = declare_device(
        '_Z21nvshmem_int64_put_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_int64_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_int64_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_put_nbi, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_int64_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_int64_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_int64_put_nbi_nbst(shim_stream, shim_obj)


def uint8_put_nbi():
    pass
    

def _lower__Z21nvshmem_uint8_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_uint8_put_nbi_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint8_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_uint8_put_nbi_nbst = declare_device(
        '_Z21nvshmem_uint8_put_nbi_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_uint8_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_uint8_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_put_nbi, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_uint8_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_uint8_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_uint8_put_nbi_nbst(shim_stream, shim_obj)


def uint16_put_nbi():
    pass
    

def _lower__Z22nvshmem_uint16_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_uint16_put_nbi_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint16_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmem_uint16_put_nbi_nbst = declare_device(
        '_Z22nvshmem_uint16_put_nbi_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_uint16_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmem_uint16_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_put_nbi, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmem_uint16_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_uint16_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_uint16_put_nbi_nbst(shim_stream, shim_obj)


def uint32_put_nbi():
    pass
    

def _lower__Z22nvshmem_uint32_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_uint32_put_nbi_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint32_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmem_uint32_put_nbi_nbst = declare_device(
        '_Z22nvshmem_uint32_put_nbi_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_uint32_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmem_uint32_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_put_nbi, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmem_uint32_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_uint32_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_uint32_put_nbi_nbst(shim_stream, shim_obj)


def uint64_put_nbi():
    pass
    

def _lower__Z22nvshmem_uint64_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_uint64_put_nbi_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint64_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmem_uint64_put_nbi_nbst = declare_device(
        '_Z22nvshmem_uint64_put_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_uint64_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmem_uint64_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_put_nbi, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmem_uint64_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_uint64_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_uint64_put_nbi_nbst(shim_stream, shim_obj)


def size_put_nbi():
    pass
    

def _lower__Z20nvshmem_size_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_size_put_nbi_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmem_size_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmem_size_put_nbi_nbst = declare_device(
        '_Z20nvshmem_size_put_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_size_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmem_size_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_put_nbi, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_size_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_size_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_size_put_nbi_nbst(shim_stream, shim_obj)


def ptrdiff_put_nbi():
    pass
    

def _lower__Z23nvshmem_ptrdiff_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_ptrdiff_put_nbi_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmem_ptrdiff_put_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmem_ptrdiff_put_nbi_nbst = declare_device(
        '_Z23nvshmem_ptrdiff_put_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_ptrdiff_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmem_ptrdiff_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ptrdiff_put_nbi, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_ptrdiff_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_ptrdiff_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_ptrdiff_put_nbi_nbst(shim_stream, shim_obj)


def bfloat16_put_signal_nbi():
    pass
    

def _lower__Z31nvshmem_bfloat16_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmem_bfloat16_put_signal_nbi_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_bfloat16_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmem_bfloat16_put_signal_nbi_nbst = declare_device(
        '_Z31nvshmem_bfloat16_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmem_bfloat16_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmem_bfloat16_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(bfloat16_put_signal_nbi, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmem_bfloat16_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmem_bfloat16_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmem_bfloat16_put_signal_nbi_nbst(shim_stream, shim_obj)


def half_put_signal_nbi():
    pass
    

def _lower__Z27nvshmem_half_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_half_put_signal_nbi_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_half_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z27nvshmem_half_put_signal_nbi_nbst = declare_device(
        '_Z27nvshmem_half_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmem_half_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z27nvshmem_half_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(half_put_signal_nbi, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmem_half_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_half_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmem_half_put_signal_nbi_nbst(shim_stream, shim_obj)


def float_put_signal_nbi():
    pass
    

def _lower__Z28nvshmem_float_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_float_put_signal_nbi_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_float_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z28nvshmem_float_put_signal_nbi_nbst = declare_device(
        '_Z28nvshmem_float_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_float_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z28nvshmem_float_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(float_put_signal_nbi, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_float_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_float_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_float_put_signal_nbi_nbst(shim_stream, shim_obj)


def double_put_signal_nbi():
    pass
    

def _lower__Z29nvshmem_double_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_double_put_signal_nbi_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_double_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z29nvshmem_double_put_signal_nbi_nbst = declare_device(
        '_Z29nvshmem_double_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmem_double_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z29nvshmem_double_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(double_put_signal_nbi, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmem_double_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_double_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmem_double_put_signal_nbi_nbst(shim_stream, shim_obj)


def char_put_signal_nbi():
    pass
    

def _lower__Z27nvshmem_char_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_char_put_signal_nbi_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_char_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z27nvshmem_char_put_signal_nbi_nbst = declare_device(
        '_Z27nvshmem_char_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmem_char_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z27nvshmem_char_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(char_put_signal_nbi, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmem_char_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_char_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmem_char_put_signal_nbi_nbst(shim_stream, shim_obj)


def short_put_signal_nbi():
    pass
    

def _lower__Z28nvshmem_short_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_short_put_signal_nbi_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_short_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z28nvshmem_short_put_signal_nbi_nbst = declare_device(
        '_Z28nvshmem_short_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_short_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z28nvshmem_short_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(short_put_signal_nbi, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_short_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_short_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_short_put_signal_nbi_nbst(shim_stream, shim_obj)


def schar_put_signal_nbi():
    pass
    

def _lower__Z28nvshmem_schar_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_schar_put_signal_nbi_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_schar_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z28nvshmem_schar_put_signal_nbi_nbst = declare_device(
        '_Z28nvshmem_schar_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_schar_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z28nvshmem_schar_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(schar_put_signal_nbi, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_schar_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_schar_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_schar_put_signal_nbi_nbst(shim_stream, shim_obj)


def int_put_signal_nbi():
    pass
    

def _lower__Z26nvshmem_int_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmem_int_put_signal_nbi_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_int_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z26nvshmem_int_put_signal_nbi_nbst = declare_device(
        '_Z26nvshmem_int_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmem_int_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z26nvshmem_int_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int_put_signal_nbi, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmem_int_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmem_int_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmem_int_put_signal_nbi_nbst(shim_stream, shim_obj)


def long_put_signal_nbi():
    pass
    

def _lower__Z27nvshmem_long_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_long_put_signal_nbi_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_long_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z27nvshmem_long_put_signal_nbi_nbst = declare_device(
        '_Z27nvshmem_long_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmem_long_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z27nvshmem_long_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(long_put_signal_nbi, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmem_long_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_long_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmem_long_put_signal_nbi_nbst(shim_stream, shim_obj)


def longlong_put_signal_nbi():
    pass
    

def _lower__Z31nvshmem_longlong_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmem_longlong_put_signal_nbi_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_longlong_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmem_longlong_put_signal_nbi_nbst = declare_device(
        '_Z31nvshmem_longlong_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmem_longlong_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmem_longlong_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(longlong_put_signal_nbi, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmem_longlong_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmem_longlong_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmem_longlong_put_signal_nbi_nbst(shim_stream, shim_obj)


def uchar_put_signal_nbi():
    pass
    

def _lower__Z28nvshmem_uchar_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_uchar_put_signal_nbi_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_uchar_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z28nvshmem_uchar_put_signal_nbi_nbst = declare_device(
        '_Z28nvshmem_uchar_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_uchar_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z28nvshmem_uchar_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uchar_put_signal_nbi, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_uchar_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_uchar_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_uchar_put_signal_nbi_nbst(shim_stream, shim_obj)


def ushort_put_signal_nbi():
    pass
    

def _lower__Z29nvshmem_ushort_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_ushort_put_signal_nbi_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_ushort_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z29nvshmem_ushort_put_signal_nbi_nbst = declare_device(
        '_Z29nvshmem_ushort_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmem_ushort_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z29nvshmem_ushort_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ushort_put_signal_nbi, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmem_ushort_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_ushort_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmem_ushort_put_signal_nbi_nbst(shim_stream, shim_obj)


def uint_put_signal_nbi():
    pass
    

def _lower__Z27nvshmem_uint_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_uint_put_signal_nbi_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_uint_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z27nvshmem_uint_put_signal_nbi_nbst = declare_device(
        '_Z27nvshmem_uint_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmem_uint_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z27nvshmem_uint_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint_put_signal_nbi, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmem_uint_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_uint_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmem_uint_put_signal_nbi_nbst(shim_stream, shim_obj)


def ulong_put_signal_nbi():
    pass
    

def _lower__Z28nvshmem_ulong_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_ulong_put_signal_nbi_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_ulong_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z28nvshmem_ulong_put_signal_nbi_nbst = declare_device(
        '_Z28nvshmem_ulong_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_ulong_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z28nvshmem_ulong_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ulong_put_signal_nbi, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_ulong_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_ulong_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_ulong_put_signal_nbi_nbst(shim_stream, shim_obj)


def ulonglong_put_signal_nbi():
    pass
    

def _lower__Z32nvshmem_ulonglong_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmem_ulonglong_put_signal_nbi_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_ulonglong_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z32nvshmem_ulonglong_put_signal_nbi_nbst = declare_device(
        '_Z32nvshmem_ulonglong_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmem_ulonglong_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z32nvshmem_ulonglong_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ulonglong_put_signal_nbi, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmem_ulonglong_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmem_ulonglong_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmem_ulonglong_put_signal_nbi_nbst(shim_stream, shim_obj)


def int8_put_signal_nbi():
    pass
    

def _lower__Z27nvshmem_int8_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_int8_put_signal_nbi_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_int8_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z27nvshmem_int8_put_signal_nbi_nbst = declare_device(
        '_Z27nvshmem_int8_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmem_int8_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z27nvshmem_int8_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int8_put_signal_nbi, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmem_int8_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_int8_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmem_int8_put_signal_nbi_nbst(shim_stream, shim_obj)


def int16_put_signal_nbi():
    pass
    

def _lower__Z28nvshmem_int16_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_int16_put_signal_nbi_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_int16_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z28nvshmem_int16_put_signal_nbi_nbst = declare_device(
        '_Z28nvshmem_int16_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_int16_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z28nvshmem_int16_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int16_put_signal_nbi, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_int16_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_int16_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_int16_put_signal_nbi_nbst(shim_stream, shim_obj)


def int32_put_signal_nbi():
    pass
    

def _lower__Z28nvshmem_int32_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_int32_put_signal_nbi_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_int32_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z28nvshmem_int32_put_signal_nbi_nbst = declare_device(
        '_Z28nvshmem_int32_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_int32_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z28nvshmem_int32_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int32_put_signal_nbi, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_int32_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_int32_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_int32_put_signal_nbi_nbst(shim_stream, shim_obj)


def int64_put_signal_nbi():
    pass
    

def _lower__Z28nvshmem_int64_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_int64_put_signal_nbi_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_int64_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z28nvshmem_int64_put_signal_nbi_nbst = declare_device(
        '_Z28nvshmem_int64_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_int64_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z28nvshmem_int64_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int64_put_signal_nbi, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_int64_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_int64_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_int64_put_signal_nbi_nbst(shim_stream, shim_obj)


def uint8_put_signal_nbi():
    pass
    

def _lower__Z28nvshmem_uint8_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_uint8_put_signal_nbi_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_uint8_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z28nvshmem_uint8_put_signal_nbi_nbst = declare_device(
        '_Z28nvshmem_uint8_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_uint8_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z28nvshmem_uint8_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint8_put_signal_nbi, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_uint8_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_uint8_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_uint8_put_signal_nbi_nbst(shim_stream, shim_obj)


def uint16_put_signal_nbi():
    pass
    

def _lower__Z29nvshmem_uint16_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_uint16_put_signal_nbi_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_uint16_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z29nvshmem_uint16_put_signal_nbi_nbst = declare_device(
        '_Z29nvshmem_uint16_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmem_uint16_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z29nvshmem_uint16_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint16_put_signal_nbi, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmem_uint16_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_uint16_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmem_uint16_put_signal_nbi_nbst(shim_stream, shim_obj)


def uint32_put_signal_nbi():
    pass
    

def _lower__Z29nvshmem_uint32_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_uint32_put_signal_nbi_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_uint32_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z29nvshmem_uint32_put_signal_nbi_nbst = declare_device(
        '_Z29nvshmem_uint32_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmem_uint32_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z29nvshmem_uint32_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint32_put_signal_nbi, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmem_uint32_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_uint32_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmem_uint32_put_signal_nbi_nbst(shim_stream, shim_obj)


def uint64_put_signal_nbi():
    pass
    

def _lower__Z29nvshmem_uint64_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_uint64_put_signal_nbi_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_uint64_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z29nvshmem_uint64_put_signal_nbi_nbst = declare_device(
        '_Z29nvshmem_uint64_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmem_uint64_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z29nvshmem_uint64_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint64_put_signal_nbi, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmem_uint64_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_uint64_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmem_uint64_put_signal_nbi_nbst(shim_stream, shim_obj)


def size_put_signal_nbi():
    pass
    

def _lower__Z27nvshmem_size_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_size_put_signal_nbi_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_size_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z27nvshmem_size_put_signal_nbi_nbst = declare_device(
        '_Z27nvshmem_size_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmem_size_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z27nvshmem_size_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(size_put_signal_nbi, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmem_size_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_size_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmem_size_put_signal_nbi_nbst(shim_stream, shim_obj)


def ptrdiff_put_signal_nbi():
    pass
    

def _lower__Z30nvshmem_ptrdiff_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_ptrdiff_put_signal_nbi_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_ptrdiff_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmem_ptrdiff_put_signal_nbi_nbst = declare_device(
        '_Z30nvshmem_ptrdiff_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmem_ptrdiff_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmem_ptrdiff_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ptrdiff_put_signal_nbi, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmem_ptrdiff_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_ptrdiff_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmem_ptrdiff_put_signal_nbi_nbst(shim_stream, shim_obj)


def bfloat16_get_nbi():
    pass
    

def _lower__Z24nvshmem_bfloat16_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_bfloat16_get_nbi_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe) {
        nvshmem_bfloat16_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmem_bfloat16_get_nbi_nbst = declare_device(
        '_Z24nvshmem_bfloat16_get_nbi_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_bfloat16_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmem_bfloat16_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_get_nbi, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_bfloat16_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_bfloat16_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_bfloat16_get_nbi_nbst(shim_stream, shim_obj)


def half_get_nbi():
    pass
    

def _lower__Z20nvshmem_half_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_half_get_nbi_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe) {
        nvshmem_half_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmem_half_get_nbi_nbst = declare_device(
        '_Z20nvshmem_half_get_nbi_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_half_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmem_half_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_get_nbi, CPointer(float16), CPointer(float16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_half_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_half_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_half_get_nbi_nbst(shim_stream, shim_obj)


def float_get_nbi():
    pass
    

def _lower__Z21nvshmem_float_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_float_get_nbi_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe) {
        nvshmem_float_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_float_get_nbi_nbst = declare_device(
        '_Z21nvshmem_float_get_nbi_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_float_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_float_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_get_nbi, CPointer(float32), CPointer(float32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_float_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_float_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_float_get_nbi_nbst(shim_stream, shim_obj)


def double_get_nbi():
    pass
    

def _lower__Z22nvshmem_double_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_double_get_nbi_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe) {
        nvshmem_double_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmem_double_get_nbi_nbst = declare_device(
        '_Z22nvshmem_double_get_nbi_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_double_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmem_double_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_get_nbi, CPointer(float64), CPointer(float64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmem_double_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_double_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_double_get_nbi_nbst(shim_stream, shim_obj)


def char_get_nbi():
    pass
    

def _lower__Z20nvshmem_char_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_char_get_nbi_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe) {
        nvshmem_char_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmem_char_get_nbi_nbst = declare_device(
        '_Z20nvshmem_char_get_nbi_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_char_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmem_char_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_get_nbi, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_char_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_char_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_char_get_nbi_nbst(shim_stream, shim_obj)


def short_get_nbi():
    pass
    

def _lower__Z21nvshmem_short_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_short_get_nbi_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe) {
        nvshmem_short_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_short_get_nbi_nbst = declare_device(
        '_Z21nvshmem_short_get_nbi_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_short_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_short_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_get_nbi, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_short_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_short_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_short_get_nbi_nbst(shim_stream, shim_obj)


def schar_get_nbi():
    pass
    

def _lower__Z21nvshmem_schar_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_schar_get_nbi_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe) {
        nvshmem_schar_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_schar_get_nbi_nbst = declare_device(
        '_Z21nvshmem_schar_get_nbi_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_schar_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_schar_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_get_nbi, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_schar_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_schar_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_schar_get_nbi_nbst(shim_stream, shim_obj)


def int_get_nbi():
    pass
    

def _lower__Z19nvshmem_int_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_int_get_nbi_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe) {
        nvshmem_int_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmem_int_get_nbi_nbst = declare_device(
        '_Z19nvshmem_int_get_nbi_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmem_int_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmem_int_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_get_nbi, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmem_int_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_int_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmem_int_get_nbi_nbst(shim_stream, shim_obj)


def long_get_nbi():
    pass
    

def _lower__Z20nvshmem_long_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_long_get_nbi_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmem_long_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmem_long_get_nbi_nbst = declare_device(
        '_Z20nvshmem_long_get_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_long_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmem_long_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_get_nbi, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_long_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_long_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_long_get_nbi_nbst(shim_stream, shim_obj)


def longlong_get_nbi():
    pass
    

def _lower__Z24nvshmem_longlong_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_longlong_get_nbi_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe) {
        nvshmem_longlong_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmem_longlong_get_nbi_nbst = declare_device(
        '_Z24nvshmem_longlong_get_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_longlong_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmem_longlong_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_get_nbi, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_longlong_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_longlong_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_longlong_get_nbi_nbst(shim_stream, shim_obj)


def uchar_get_nbi():
    pass
    

def _lower__Z21nvshmem_uchar_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_uchar_get_nbi_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe) {
        nvshmem_uchar_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_uchar_get_nbi_nbst = declare_device(
        '_Z21nvshmem_uchar_get_nbi_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_uchar_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_uchar_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_get_nbi, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_uchar_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_uchar_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_uchar_get_nbi_nbst(shim_stream, shim_obj)


def ushort_get_nbi():
    pass
    

def _lower__Z22nvshmem_ushort_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_ushort_get_nbi_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe) {
        nvshmem_ushort_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmem_ushort_get_nbi_nbst = declare_device(
        '_Z22nvshmem_ushort_get_nbi_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_ushort_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmem_ushort_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_get_nbi, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmem_ushort_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_ushort_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_ushort_get_nbi_nbst(shim_stream, shim_obj)


def uint_get_nbi():
    pass
    

def _lower__Z20nvshmem_uint_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_uint_get_nbi_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmem_uint_get_nbi_nbst = declare_device(
        '_Z20nvshmem_uint_get_nbi_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_uint_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmem_uint_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_get_nbi, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_uint_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_uint_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_uint_get_nbi_nbst(shim_stream, shim_obj)


def ulong_get_nbi():
    pass
    

def _lower__Z21nvshmem_ulong_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_ulong_get_nbi_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmem_ulong_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_ulong_get_nbi_nbst = declare_device(
        '_Z21nvshmem_ulong_get_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_ulong_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_ulong_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_get_nbi, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_ulong_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_ulong_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_ulong_get_nbi_nbst(shim_stream, shim_obj)


def ulonglong_get_nbi():
    pass
    

def _lower__Z25nvshmem_ulonglong_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_ulonglong_get_nbi_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe) {
        nvshmem_ulonglong_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmem_ulonglong_get_nbi_nbst = declare_device(
        '_Z25nvshmem_ulonglong_get_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_ulonglong_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmem_ulonglong_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_get_nbi, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_ulonglong_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_ulonglong_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_ulonglong_get_nbi_nbst(shim_stream, shim_obj)


def int8_get_nbi():
    pass
    

def _lower__Z20nvshmem_int8_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_int8_get_nbi_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_int8_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmem_int8_get_nbi_nbst = declare_device(
        '_Z20nvshmem_int8_get_nbi_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_int8_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmem_int8_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_get_nbi, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_int8_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_int8_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_int8_get_nbi_nbst(shim_stream, shim_obj)


def int16_get_nbi():
    pass
    

def _lower__Z21nvshmem_int16_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_int16_get_nbi_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_int16_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_int16_get_nbi_nbst = declare_device(
        '_Z21nvshmem_int16_get_nbi_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_int16_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_int16_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_get_nbi, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_int16_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_int16_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_int16_get_nbi_nbst(shim_stream, shim_obj)


def int32_get_nbi():
    pass
    

def _lower__Z21nvshmem_int32_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_int32_get_nbi_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_int32_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_int32_get_nbi_nbst = declare_device(
        '_Z21nvshmem_int32_get_nbi_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_int32_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_int32_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_get_nbi, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_int32_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_int32_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_int32_get_nbi_nbst(shim_stream, shim_obj)


def int64_get_nbi():
    pass
    

def _lower__Z21nvshmem_int64_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_int64_get_nbi_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_int64_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_int64_get_nbi_nbst = declare_device(
        '_Z21nvshmem_int64_get_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_int64_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_int64_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_get_nbi, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_int64_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_int64_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_int64_get_nbi_nbst(shim_stream, shim_obj)


def uint8_get_nbi():
    pass
    

def _lower__Z21nvshmem_uint8_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_uint8_get_nbi_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint8_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_uint8_get_nbi_nbst = declare_device(
        '_Z21nvshmem_uint8_get_nbi_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_uint8_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmem_uint8_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_get_nbi, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_uint8_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_uint8_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_uint8_get_nbi_nbst(shim_stream, shim_obj)


def uint16_get_nbi():
    pass
    

def _lower__Z22nvshmem_uint16_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_uint16_get_nbi_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint16_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmem_uint16_get_nbi_nbst = declare_device(
        '_Z22nvshmem_uint16_get_nbi_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_uint16_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmem_uint16_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_get_nbi, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmem_uint16_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_uint16_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_uint16_get_nbi_nbst(shim_stream, shim_obj)


def uint32_get_nbi():
    pass
    

def _lower__Z22nvshmem_uint32_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_uint32_get_nbi_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint32_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmem_uint32_get_nbi_nbst = declare_device(
        '_Z22nvshmem_uint32_get_nbi_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_uint32_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmem_uint32_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_get_nbi, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmem_uint32_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_uint32_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_uint32_get_nbi_nbst(shim_stream, shim_obj)


def uint64_get_nbi():
    pass
    

def _lower__Z22nvshmem_uint64_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_uint64_get_nbi_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe) {
        nvshmem_uint64_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmem_uint64_get_nbi_nbst = declare_device(
        '_Z22nvshmem_uint64_get_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_uint64_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmem_uint64_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_get_nbi, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmem_uint64_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_uint64_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_uint64_get_nbi_nbst(shim_stream, shim_obj)


def size_get_nbi():
    pass
    

def _lower__Z20nvshmem_size_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_size_get_nbi_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmem_size_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmem_size_get_nbi_nbst = declare_device(
        '_Z20nvshmem_size_get_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_size_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmem_size_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_get_nbi, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_size_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_size_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_size_get_nbi_nbst(shim_stream, shim_obj)


def ptrdiff_get_nbi():
    pass
    

def _lower__Z23nvshmem_ptrdiff_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_ptrdiff_get_nbi_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmem_ptrdiff_get_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmem_ptrdiff_get_nbi_nbst = declare_device(
        '_Z23nvshmem_ptrdiff_get_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_ptrdiff_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmem_ptrdiff_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ptrdiff_get_nbi, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_ptrdiff_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_ptrdiff_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_ptrdiff_get_nbi_nbst(shim_stream, shim_obj)


def put8_nbi():
    pass
    

def _lower__Z16nvshmem_put8_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_put8_nbi_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_put8_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z16nvshmem_put8_nbi_nbst = declare_device(
        '_Z16nvshmem_put8_nbi_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_put8_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z16nvshmem_put8_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put8_nbi, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_put8_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_put8_nbi_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_put8_nbi_nbst(shim_stream, shim_obj)


def put16_nbi():
    pass
    

def _lower__Z17nvshmem_put16_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_put16_nbi_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_put16_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_put16_nbi_nbst = declare_device(
        '_Z17nvshmem_put16_nbi_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_put16_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_put16_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put16_nbi, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_put16_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_put16_nbi_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_put16_nbi_nbst(shim_stream, shim_obj)


def put32_nbi():
    pass
    

def _lower__Z17nvshmem_put32_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_put32_nbi_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_put32_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_put32_nbi_nbst = declare_device(
        '_Z17nvshmem_put32_nbi_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_put32_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_put32_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put32_nbi, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_put32_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_put32_nbi_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_put32_nbi_nbst(shim_stream, shim_obj)


def put64_nbi():
    pass
    

def _lower__Z17nvshmem_put64_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_put64_nbi_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_put64_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_put64_nbi_nbst = declare_device(
        '_Z17nvshmem_put64_nbi_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_put64_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_put64_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put64_nbi, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_put64_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_put64_nbi_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_put64_nbi_nbst(shim_stream, shim_obj)


def put128_nbi():
    pass
    

def _lower__Z18nvshmem_put128_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_put128_nbi_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_put128_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_put128_nbi_nbst = declare_device(
        '_Z18nvshmem_put128_nbi_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_put128_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmem_put128_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put128_nbi, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_put128_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_put128_nbi_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_put128_nbi_nbst(shim_stream, shim_obj)


def get8_nbi():
    pass
    

def _lower__Z16nvshmem_get8_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_get8_nbi_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_get8_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z16nvshmem_get8_nbi_nbst = declare_device(
        '_Z16nvshmem_get8_nbi_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_get8_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z16nvshmem_get8_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get8_nbi, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_get8_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_get8_nbi_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_get8_nbi_nbst(shim_stream, shim_obj)


def get16_nbi():
    pass
    

def _lower__Z17nvshmem_get16_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_get16_nbi_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_get16_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_get16_nbi_nbst = declare_device(
        '_Z17nvshmem_get16_nbi_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_get16_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_get16_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get16_nbi, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_get16_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_get16_nbi_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_get16_nbi_nbst(shim_stream, shim_obj)


def get32_nbi():
    pass
    

def _lower__Z17nvshmem_get32_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_get32_nbi_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_get32_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_get32_nbi_nbst = declare_device(
        '_Z17nvshmem_get32_nbi_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_get32_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_get32_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get32_nbi, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_get32_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_get32_nbi_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_get32_nbi_nbst(shim_stream, shim_obj)


def get64_nbi():
    pass
    

def _lower__Z17nvshmem_get64_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_get64_nbi_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_get64_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_get64_nbi_nbst = declare_device(
        '_Z17nvshmem_get64_nbi_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_get64_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmem_get64_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get64_nbi, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_get64_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_get64_nbi_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_get64_nbi_nbst(shim_stream, shim_obj)


def get128_nbi():
    pass
    

def _lower__Z18nvshmem_get128_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_get128_nbi_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmem_get128_nbi(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_get128_nbi_nbst = declare_device(
        '_Z18nvshmem_get128_nbi_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_get128_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmem_get128_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get128_nbi, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_get128_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_get128_nbi_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_get128_nbi_nbst(shim_stream, shim_obj)


def putmem_nbi():
    pass
    

def _lower__Z18nvshmem_putmem_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_putmem_nbi_nbst(int &retval , void ** dest, void ** source, unsigned long* bytes, int* pe) {
        nvshmem_putmem_nbi(*dest, *source, *bytes, *pe);
        return 0;
    }
        """


    _Z18nvshmem_putmem_nbi_nbst = declare_device(
        '_Z18nvshmem_putmem_nbi_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_putmem_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmem_putmem_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(putmem_nbi, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_putmem_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_putmem_nbi_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_putmem_nbi_nbst(shim_stream, shim_obj)


def putmem_signal_nbi():
    pass
    

def _lower__Z25nvshmem_putmem_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_putmem_signal_nbi_nbst(int &retval , void ** dest, void ** source, unsigned long* bytes, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_putmem_signal_nbi(*dest, *source, *bytes, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z25nvshmem_putmem_signal_nbi_nbst = declare_device(
        '_Z25nvshmem_putmem_signal_nbi_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_putmem_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z25nvshmem_putmem_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(putmem_signal_nbi, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_putmem_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_putmem_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_putmem_signal_nbi_nbst(shim_stream, shim_obj)


def put8_signal_nbi():
    pass
    

def _lower__Z23nvshmem_put8_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_put8_signal_nbi_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_put8_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z23nvshmem_put8_signal_nbi_nbst = declare_device(
        '_Z23nvshmem_put8_signal_nbi_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_put8_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z23nvshmem_put8_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put8_signal_nbi, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_put8_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_put8_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_put8_signal_nbi_nbst(shim_stream, shim_obj)


def put16_signal_nbi():
    pass
    

def _lower__Z24nvshmem_put16_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_put16_signal_nbi_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_put16_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z24nvshmem_put16_signal_nbi_nbst = declare_device(
        '_Z24nvshmem_put16_signal_nbi_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_put16_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z24nvshmem_put16_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put16_signal_nbi, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_put16_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_put16_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_put16_signal_nbi_nbst(shim_stream, shim_obj)


def put32_signal_nbi():
    pass
    

def _lower__Z24nvshmem_put32_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_put32_signal_nbi_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_put32_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z24nvshmem_put32_signal_nbi_nbst = declare_device(
        '_Z24nvshmem_put32_signal_nbi_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_put32_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z24nvshmem_put32_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put32_signal_nbi, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_put32_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_put32_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_put32_signal_nbi_nbst(shim_stream, shim_obj)


def put64_signal_nbi():
    pass
    

def _lower__Z24nvshmem_put64_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_put64_signal_nbi_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_put64_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z24nvshmem_put64_signal_nbi_nbst = declare_device(
        '_Z24nvshmem_put64_signal_nbi_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_put64_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z24nvshmem_put64_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put64_signal_nbi, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_put64_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_put64_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_put64_signal_nbi_nbst(shim_stream, shim_obj)


def put128_signal_nbi():
    pass
    

def _lower__Z25nvshmem_put128_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_put128_signal_nbi_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmem_put128_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z25nvshmem_put128_signal_nbi_nbst = declare_device(
        '_Z25nvshmem_put128_signal_nbi_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_put128_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z25nvshmem_put128_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put128_signal_nbi, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_put128_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_put128_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_put128_signal_nbi_nbst(shim_stream, shim_obj)


def getmem_nbi():
    pass
    

def _lower__Z18nvshmem_getmem_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_getmem_nbi_nbst(int &retval , void ** dest, void ** source, unsigned long* bytes, int* pe) {
        nvshmem_getmem_nbi(*dest, *source, *bytes, *pe);
        return 0;
    }
        """


    _Z18nvshmem_getmem_nbi_nbst = declare_device(
        '_Z18nvshmem_getmem_nbi_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_getmem_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmem_getmem_nbi_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(getmem_nbi, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_getmem_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_getmem_nbi_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_getmem_nbi_nbst(shim_stream, shim_obj)


def bfloat16_iput():
    pass
    

def _lower__Z21nvshmem_bfloat16_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_bfloat16_iput_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_bfloat16_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_bfloat16_iput_nbst = declare_device(
        '_Z21nvshmem_bfloat16_iput_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_bfloat16_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z21nvshmem_bfloat16_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(bfloat16_iput, CPointer(bfloat16), CPointer(bfloat16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_bfloat16_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_bfloat16_iput_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_bfloat16_iput_nbst(shim_stream, shim_obj)


def half_iput():
    pass
    

def _lower__Z17nvshmem_half_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_half_iput_nbst(int &retval , __half ** dest, __half ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_half_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_half_iput_nbst = declare_device(
        '_Z17nvshmem_half_iput_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_half_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z17nvshmem_half_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(half_iput, CPointer(float16), CPointer(float16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_half_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_half_iput_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_half_iput_nbst(shim_stream, shim_obj)


def float_iput():
    pass
    

def _lower__Z18nvshmem_float_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_float_iput_nbst(int &retval , float ** dest, float ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_float_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_float_iput_nbst = declare_device(
        '_Z18nvshmem_float_iput_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_float_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z18nvshmem_float_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(float_iput, CPointer(float32), CPointer(float32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_float_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_float_iput_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_float_iput_nbst(shim_stream, shim_obj)


def double_iput():
    pass
    

def _lower__Z19nvshmem_double_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_double_iput_nbst(int &retval , double ** dest, double ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_double_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmem_double_iput_nbst = declare_device(
        '_Z19nvshmem_double_iput_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmem_double_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z19nvshmem_double_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(double_iput, CPointer(float64), CPointer(float64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmem_double_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_double_iput_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmem_double_iput_nbst(shim_stream, shim_obj)


def char_iput():
    pass
    

def _lower__Z17nvshmem_char_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_char_iput_nbst(int &retval , char ** dest, char ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_char_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_char_iput_nbst = declare_device(
        '_Z17nvshmem_char_iput_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_char_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z17nvshmem_char_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(char_iput, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_char_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_char_iput_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_char_iput_nbst(shim_stream, shim_obj)


def short_iput():
    pass
    

def _lower__Z18nvshmem_short_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_short_iput_nbst(int &retval , short ** dest, short ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_short_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_short_iput_nbst = declare_device(
        '_Z18nvshmem_short_iput_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_short_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z18nvshmem_short_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(short_iput, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_short_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_short_iput_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_short_iput_nbst(shim_stream, shim_obj)


def schar_iput():
    pass
    

def _lower__Z18nvshmem_schar_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_schar_iput_nbst(int &retval , signed char ** dest, signed char ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_schar_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_schar_iput_nbst = declare_device(
        '_Z18nvshmem_schar_iput_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_schar_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z18nvshmem_schar_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(schar_iput, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_schar_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_schar_iput_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_schar_iput_nbst(shim_stream, shim_obj)


def int_iput():
    pass
    

def _lower__Z16nvshmem_int_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_int_iput_nbst(int &retval , int ** dest, int ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_int_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z16nvshmem_int_iput_nbst = declare_device(
        '_Z16nvshmem_int_iput_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_int_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z16nvshmem_int_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int_iput, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_int_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_int_iput_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_int_iput_nbst(shim_stream, shim_obj)


def long_iput():
    pass
    

def _lower__Z17nvshmem_long_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_long_iput_nbst(int &retval , long ** dest, long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_long_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_long_iput_nbst = declare_device(
        '_Z17nvshmem_long_iput_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_long_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z17nvshmem_long_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(long_iput, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_long_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_long_iput_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_long_iput_nbst(shim_stream, shim_obj)


def longlong_iput():
    pass
    

def _lower__Z21nvshmem_longlong_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_longlong_iput_nbst(int &retval , long long ** dest, long long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_longlong_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_longlong_iput_nbst = declare_device(
        '_Z21nvshmem_longlong_iput_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_longlong_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z21nvshmem_longlong_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(longlong_iput, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_longlong_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_longlong_iput_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_longlong_iput_nbst(shim_stream, shim_obj)


def uchar_iput():
    pass
    

def _lower__Z18nvshmem_uchar_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_uchar_iput_nbst(int &retval , unsigned char ** dest, unsigned char ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_uchar_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_uchar_iput_nbst = declare_device(
        '_Z18nvshmem_uchar_iput_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_uchar_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z18nvshmem_uchar_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uchar_iput, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_uchar_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_uchar_iput_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_uchar_iput_nbst(shim_stream, shim_obj)


def ushort_iput():
    pass
    

def _lower__Z19nvshmem_ushort_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_ushort_iput_nbst(int &retval , unsigned short ** dest, unsigned short ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_ushort_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmem_ushort_iput_nbst = declare_device(
        '_Z19nvshmem_ushort_iput_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmem_ushort_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z19nvshmem_ushort_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ushort_iput, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmem_ushort_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_ushort_iput_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmem_ushort_iput_nbst(shim_stream, shim_obj)


def uint_iput():
    pass
    

def _lower__Z17nvshmem_uint_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_uint_iput_nbst(int &retval , unsigned int ** dest, unsigned int ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_uint_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_uint_iput_nbst = declare_device(
        '_Z17nvshmem_uint_iput_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_uint_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z17nvshmem_uint_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint_iput, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_uint_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_uint_iput_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_uint_iput_nbst(shim_stream, shim_obj)


def ulong_iput():
    pass
    

def _lower__Z18nvshmem_ulong_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_ulong_iput_nbst(int &retval , unsigned long ** dest, unsigned long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_ulong_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_ulong_iput_nbst = declare_device(
        '_Z18nvshmem_ulong_iput_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_ulong_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z18nvshmem_ulong_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulong_iput, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_ulong_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_ulong_iput_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_ulong_iput_nbst(shim_stream, shim_obj)


def ulonglong_iput():
    pass
    

def _lower__Z22nvshmem_ulonglong_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_ulonglong_iput_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_ulonglong_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmem_ulonglong_iput_nbst = declare_device(
        '_Z22nvshmem_ulonglong_iput_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_ulonglong_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z22nvshmem_ulonglong_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulonglong_iput, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmem_ulonglong_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_ulonglong_iput_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_ulonglong_iput_nbst(shim_stream, shim_obj)


def int8_iput():
    pass
    

def _lower__Z17nvshmem_int8_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_int8_iput_nbst(int &retval , int8_t ** dest, int8_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_int8_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_int8_iput_nbst = declare_device(
        '_Z17nvshmem_int8_iput_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_int8_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z17nvshmem_int8_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int8_iput, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_int8_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_int8_iput_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_int8_iput_nbst(shim_stream, shim_obj)


def int16_iput():
    pass
    

def _lower__Z18nvshmem_int16_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_int16_iput_nbst(int &retval , int16_t ** dest, int16_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_int16_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_int16_iput_nbst = declare_device(
        '_Z18nvshmem_int16_iput_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_int16_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z18nvshmem_int16_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int16_iput, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_int16_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_int16_iput_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_int16_iput_nbst(shim_stream, shim_obj)


def int32_iput():
    pass
    

def _lower__Z18nvshmem_int32_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_int32_iput_nbst(int &retval , int32_t ** dest, int32_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_int32_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_int32_iput_nbst = declare_device(
        '_Z18nvshmem_int32_iput_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_int32_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z18nvshmem_int32_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int32_iput, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_int32_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_int32_iput_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_int32_iput_nbst(shim_stream, shim_obj)


def int64_iput():
    pass
    

def _lower__Z18nvshmem_int64_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_int64_iput_nbst(int &retval , int64_t ** dest, int64_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_int64_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_int64_iput_nbst = declare_device(
        '_Z18nvshmem_int64_iput_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_int64_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z18nvshmem_int64_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int64_iput, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_int64_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_int64_iput_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_int64_iput_nbst(shim_stream, shim_obj)


def uint8_iput():
    pass
    

def _lower__Z18nvshmem_uint8_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_uint8_iput_nbst(int &retval , uint8_t ** dest, uint8_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_uint8_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_uint8_iput_nbst = declare_device(
        '_Z18nvshmem_uint8_iput_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_uint8_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z18nvshmem_uint8_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint8_iput, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_uint8_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_uint8_iput_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_uint8_iput_nbst(shim_stream, shim_obj)


def uint16_iput():
    pass
    

def _lower__Z19nvshmem_uint16_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_uint16_iput_nbst(int &retval , uint16_t ** dest, uint16_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_uint16_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmem_uint16_iput_nbst = declare_device(
        '_Z19nvshmem_uint16_iput_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmem_uint16_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z19nvshmem_uint16_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint16_iput, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmem_uint16_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_uint16_iput_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmem_uint16_iput_nbst(shim_stream, shim_obj)


def uint32_iput():
    pass
    

def _lower__Z19nvshmem_uint32_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_uint32_iput_nbst(int &retval , uint32_t ** dest, uint32_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_uint32_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmem_uint32_iput_nbst = declare_device(
        '_Z19nvshmem_uint32_iput_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmem_uint32_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z19nvshmem_uint32_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint32_iput, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmem_uint32_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_uint32_iput_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmem_uint32_iput_nbst(shim_stream, shim_obj)


def uint64_iput():
    pass
    

def _lower__Z19nvshmem_uint64_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_uint64_iput_nbst(int &retval , uint64_t ** dest, uint64_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_uint64_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmem_uint64_iput_nbst = declare_device(
        '_Z19nvshmem_uint64_iput_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmem_uint64_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z19nvshmem_uint64_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint64_iput, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmem_uint64_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_uint64_iput_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmem_uint64_iput_nbst(shim_stream, shim_obj)


def size_iput():
    pass
    

def _lower__Z17nvshmem_size_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_size_iput_nbst(int &retval , unsigned long ** dest, unsigned long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_size_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_size_iput_nbst = declare_device(
        '_Z17nvshmem_size_iput_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_size_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z17nvshmem_size_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(size_iput, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_size_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_size_iput_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_size_iput_nbst(shim_stream, shim_obj)


def ptrdiff_iput():
    pass
    

def _lower__Z20nvshmem_ptrdiff_iput_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_ptrdiff_iput_nbst(int &retval , long ** dest, long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_ptrdiff_iput(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmem_ptrdiff_iput_nbst = declare_device(
        '_Z20nvshmem_ptrdiff_iput_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_ptrdiff_iput_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z20nvshmem_ptrdiff_iput_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ptrdiff_iput, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_ptrdiff_iput_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_ptrdiff_iput_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_ptrdiff_iput_nbst(shim_stream, shim_obj)


def iput8():
    pass
    

def _lower__Z13nvshmem_iput8_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z13nvshmem_iput8_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_iput8(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z13nvshmem_iput8_nbst = declare_device(
        '_Z13nvshmem_iput8_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z13nvshmem_iput8_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z13nvshmem_iput8_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iput8, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z13nvshmem_iput8_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z13nvshmem_iput8_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z13nvshmem_iput8_nbst(shim_stream, shim_obj)


def iput16():
    pass
    

def _lower__Z14nvshmem_iput16_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_iput16_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_iput16(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z14nvshmem_iput16_nbst = declare_device(
        '_Z14nvshmem_iput16_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_iput16_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z14nvshmem_iput16_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iput16, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_iput16_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_iput16_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_iput16_nbst(shim_stream, shim_obj)


def iput32():
    pass
    

def _lower__Z14nvshmem_iput32_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_iput32_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_iput32(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z14nvshmem_iput32_nbst = declare_device(
        '_Z14nvshmem_iput32_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_iput32_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z14nvshmem_iput32_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iput32, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_iput32_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_iput32_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_iput32_nbst(shim_stream, shim_obj)


def iput64():
    pass
    

def _lower__Z14nvshmem_iput64_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_iput64_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_iput64(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z14nvshmem_iput64_nbst = declare_device(
        '_Z14nvshmem_iput64_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_iput64_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z14nvshmem_iput64_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iput64, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_iput64_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_iput64_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_iput64_nbst(shim_stream, shim_obj)


def iput128():
    pass
    

def _lower__Z15nvshmem_iput128_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_iput128_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_iput128(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z15nvshmem_iput128_nbst = declare_device(
        '_Z15nvshmem_iput128_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_iput128_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z15nvshmem_iput128_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iput128, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_iput128_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_iput128_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_iput128_nbst(shim_stream, shim_obj)


def bfloat16_iget():
    pass
    

def _lower__Z21nvshmem_bfloat16_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_bfloat16_iget_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_bfloat16_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_bfloat16_iget_nbst = declare_device(
        '_Z21nvshmem_bfloat16_iget_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_bfloat16_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z21nvshmem_bfloat16_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(bfloat16_iget, CPointer(bfloat16), CPointer(bfloat16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_bfloat16_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_bfloat16_iget_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_bfloat16_iget_nbst(shim_stream, shim_obj)


def half_iget():
    pass
    

def _lower__Z17nvshmem_half_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_half_iget_nbst(int &retval , __half ** dest, __half ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_half_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_half_iget_nbst = declare_device(
        '_Z17nvshmem_half_iget_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_half_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z17nvshmem_half_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(half_iget, CPointer(float16), CPointer(float16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_half_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_half_iget_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_half_iget_nbst(shim_stream, shim_obj)


def float_iget():
    pass
    

def _lower__Z18nvshmem_float_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_float_iget_nbst(int &retval , float ** dest, float ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_float_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_float_iget_nbst = declare_device(
        '_Z18nvshmem_float_iget_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_float_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z18nvshmem_float_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(float_iget, CPointer(float32), CPointer(float32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_float_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_float_iget_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_float_iget_nbst(shim_stream, shim_obj)


def double_iget():
    pass
    

def _lower__Z19nvshmem_double_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_double_iget_nbst(int &retval , double ** dest, double ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_double_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmem_double_iget_nbst = declare_device(
        '_Z19nvshmem_double_iget_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmem_double_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z19nvshmem_double_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(double_iget, CPointer(float64), CPointer(float64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmem_double_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_double_iget_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmem_double_iget_nbst(shim_stream, shim_obj)


def char_iget():
    pass
    

def _lower__Z17nvshmem_char_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_char_iget_nbst(int &retval , char ** dest, char ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_char_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_char_iget_nbst = declare_device(
        '_Z17nvshmem_char_iget_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_char_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z17nvshmem_char_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(char_iget, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_char_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_char_iget_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_char_iget_nbst(shim_stream, shim_obj)


def short_iget():
    pass
    

def _lower__Z18nvshmem_short_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_short_iget_nbst(int &retval , short ** dest, short ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_short_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_short_iget_nbst = declare_device(
        '_Z18nvshmem_short_iget_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_short_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z18nvshmem_short_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(short_iget, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_short_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_short_iget_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_short_iget_nbst(shim_stream, shim_obj)


def schar_iget():
    pass
    

def _lower__Z18nvshmem_schar_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_schar_iget_nbst(int &retval , signed char ** dest, signed char ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_schar_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_schar_iget_nbst = declare_device(
        '_Z18nvshmem_schar_iget_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_schar_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z18nvshmem_schar_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(schar_iget, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_schar_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_schar_iget_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_schar_iget_nbst(shim_stream, shim_obj)


def int_iget():
    pass
    

def _lower__Z16nvshmem_int_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_int_iget_nbst(int &retval , int ** dest, int ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_int_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z16nvshmem_int_iget_nbst = declare_device(
        '_Z16nvshmem_int_iget_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_int_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z16nvshmem_int_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int_iget, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z16nvshmem_int_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_int_iget_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_int_iget_nbst(shim_stream, shim_obj)


def long_iget():
    pass
    

def _lower__Z17nvshmem_long_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_long_iget_nbst(int &retval , long ** dest, long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_long_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_long_iget_nbst = declare_device(
        '_Z17nvshmem_long_iget_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_long_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z17nvshmem_long_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(long_iget, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_long_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_long_iget_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_long_iget_nbst(shim_stream, shim_obj)


def longlong_iget():
    pass
    

def _lower__Z21nvshmem_longlong_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_longlong_iget_nbst(int &retval , long long ** dest, long long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_longlong_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmem_longlong_iget_nbst = declare_device(
        '_Z21nvshmem_longlong_iget_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_longlong_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z21nvshmem_longlong_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(longlong_iget, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmem_longlong_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_longlong_iget_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_longlong_iget_nbst(shim_stream, shim_obj)


def uchar_iget():
    pass
    

def _lower__Z18nvshmem_uchar_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_uchar_iget_nbst(int &retval , unsigned char ** dest, unsigned char ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_uchar_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_uchar_iget_nbst = declare_device(
        '_Z18nvshmem_uchar_iget_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_uchar_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z18nvshmem_uchar_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uchar_iget, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_uchar_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_uchar_iget_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_uchar_iget_nbst(shim_stream, shim_obj)


def ushort_iget():
    pass
    

def _lower__Z19nvshmem_ushort_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_ushort_iget_nbst(int &retval , unsigned short ** dest, unsigned short ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_ushort_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmem_ushort_iget_nbst = declare_device(
        '_Z19nvshmem_ushort_iget_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmem_ushort_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z19nvshmem_ushort_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ushort_iget, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmem_ushort_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_ushort_iget_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmem_ushort_iget_nbst(shim_stream, shim_obj)


def uint_iget():
    pass
    

def _lower__Z17nvshmem_uint_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_uint_iget_nbst(int &retval , unsigned int ** dest, unsigned int ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_uint_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_uint_iget_nbst = declare_device(
        '_Z17nvshmem_uint_iget_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_uint_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z17nvshmem_uint_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint_iget, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_uint_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_uint_iget_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_uint_iget_nbst(shim_stream, shim_obj)


def ulong_iget():
    pass
    

def _lower__Z18nvshmem_ulong_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_ulong_iget_nbst(int &retval , unsigned long ** dest, unsigned long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_ulong_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_ulong_iget_nbst = declare_device(
        '_Z18nvshmem_ulong_iget_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_ulong_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z18nvshmem_ulong_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulong_iget, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_ulong_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_ulong_iget_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_ulong_iget_nbst(shim_stream, shim_obj)


def ulonglong_iget():
    pass
    

def _lower__Z22nvshmem_ulonglong_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_ulonglong_iget_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_ulonglong_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmem_ulonglong_iget_nbst = declare_device(
        '_Z22nvshmem_ulonglong_iget_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_ulonglong_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z22nvshmem_ulonglong_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulonglong_iget, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmem_ulonglong_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_ulonglong_iget_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_ulonglong_iget_nbst(shim_stream, shim_obj)


def int8_iget():
    pass
    

def _lower__Z17nvshmem_int8_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_int8_iget_nbst(int &retval , int8_t ** dest, int8_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_int8_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_int8_iget_nbst = declare_device(
        '_Z17nvshmem_int8_iget_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_int8_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z17nvshmem_int8_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int8_iget, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_int8_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_int8_iget_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_int8_iget_nbst(shim_stream, shim_obj)


def int16_iget():
    pass
    

def _lower__Z18nvshmem_int16_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_int16_iget_nbst(int &retval , int16_t ** dest, int16_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_int16_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_int16_iget_nbst = declare_device(
        '_Z18nvshmem_int16_iget_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_int16_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z18nvshmem_int16_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int16_iget, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_int16_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_int16_iget_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_int16_iget_nbst(shim_stream, shim_obj)


def int32_iget():
    pass
    

def _lower__Z18nvshmem_int32_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_int32_iget_nbst(int &retval , int32_t ** dest, int32_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_int32_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_int32_iget_nbst = declare_device(
        '_Z18nvshmem_int32_iget_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_int32_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z18nvshmem_int32_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int32_iget, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_int32_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_int32_iget_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_int32_iget_nbst(shim_stream, shim_obj)


def int64_iget():
    pass
    

def _lower__Z18nvshmem_int64_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_int64_iget_nbst(int &retval , int64_t ** dest, int64_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_int64_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_int64_iget_nbst = declare_device(
        '_Z18nvshmem_int64_iget_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_int64_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z18nvshmem_int64_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int64_iget, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_int64_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_int64_iget_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_int64_iget_nbst(shim_stream, shim_obj)


def uint8_iget():
    pass
    

def _lower__Z18nvshmem_uint8_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_uint8_iget_nbst(int &retval , uint8_t ** dest, uint8_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_uint8_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmem_uint8_iget_nbst = declare_device(
        '_Z18nvshmem_uint8_iget_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_uint8_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z18nvshmem_uint8_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint8_iget, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmem_uint8_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_uint8_iget_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_uint8_iget_nbst(shim_stream, shim_obj)


def uint16_iget():
    pass
    

def _lower__Z19nvshmem_uint16_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_uint16_iget_nbst(int &retval , uint16_t ** dest, uint16_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_uint16_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmem_uint16_iget_nbst = declare_device(
        '_Z19nvshmem_uint16_iget_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmem_uint16_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z19nvshmem_uint16_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint16_iget, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmem_uint16_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_uint16_iget_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmem_uint16_iget_nbst(shim_stream, shim_obj)


def uint32_iget():
    pass
    

def _lower__Z19nvshmem_uint32_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_uint32_iget_nbst(int &retval , uint32_t ** dest, uint32_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_uint32_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmem_uint32_iget_nbst = declare_device(
        '_Z19nvshmem_uint32_iget_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmem_uint32_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z19nvshmem_uint32_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint32_iget, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmem_uint32_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_uint32_iget_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmem_uint32_iget_nbst(shim_stream, shim_obj)


def uint64_iget():
    pass
    

def _lower__Z19nvshmem_uint64_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_uint64_iget_nbst(int &retval , uint64_t ** dest, uint64_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_uint64_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmem_uint64_iget_nbst = declare_device(
        '_Z19nvshmem_uint64_iget_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmem_uint64_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z19nvshmem_uint64_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint64_iget, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmem_uint64_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_uint64_iget_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmem_uint64_iget_nbst(shim_stream, shim_obj)


def size_iget():
    pass
    

def _lower__Z17nvshmem_size_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_size_iget_nbst(int &retval , unsigned long ** dest, unsigned long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_size_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z17nvshmem_size_iget_nbst = declare_device(
        '_Z17nvshmem_size_iget_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z17nvshmem_size_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z17nvshmem_size_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(size_iget, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmem_size_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_size_iget_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmem_size_iget_nbst(shim_stream, shim_obj)


def ptrdiff_iget():
    pass
    

def _lower__Z20nvshmem_ptrdiff_iget_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_ptrdiff_iget_nbst(int &retval , long ** dest, long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_ptrdiff_iget(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmem_ptrdiff_iget_nbst = declare_device(
        '_Z20nvshmem_ptrdiff_iget_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_ptrdiff_iget_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z20nvshmem_ptrdiff_iget_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ptrdiff_iget, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_ptrdiff_iget_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_ptrdiff_iget_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_ptrdiff_iget_nbst(shim_stream, shim_obj)


def iget8():
    pass
    

def _lower__Z13nvshmem_iget8_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z13nvshmem_iget8_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_iget8(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z13nvshmem_iget8_nbst = declare_device(
        '_Z13nvshmem_iget8_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z13nvshmem_iget8_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z13nvshmem_iget8_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iget8, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z13nvshmem_iget8_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z13nvshmem_iget8_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z13nvshmem_iget8_nbst(shim_stream, shim_obj)


def iget16():
    pass
    

def _lower__Z14nvshmem_iget16_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_iget16_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_iget16(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z14nvshmem_iget16_nbst = declare_device(
        '_Z14nvshmem_iget16_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_iget16_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z14nvshmem_iget16_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iget16, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_iget16_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_iget16_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_iget16_nbst(shim_stream, shim_obj)


def iget32():
    pass
    

def _lower__Z14nvshmem_iget32_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_iget32_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_iget32(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z14nvshmem_iget32_nbst = declare_device(
        '_Z14nvshmem_iget32_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_iget32_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z14nvshmem_iget32_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iget32, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_iget32_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_iget32_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_iget32_nbst(shim_stream, shim_obj)


def iget64():
    pass
    

def _lower__Z14nvshmem_iget64_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z14nvshmem_iget64_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_iget64(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z14nvshmem_iget64_nbst = declare_device(
        '_Z14nvshmem_iget64_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z14nvshmem_iget64_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z14nvshmem_iget64_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iget64, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z14nvshmem_iget64_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z14nvshmem_iget64_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z14nvshmem_iget64_nbst(shim_stream, shim_obj)


def iget128():
    pass
    

def _lower__Z15nvshmem_iget128_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmem_iget128_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmem_iget128(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z15nvshmem_iget128_nbst = declare_device(
        '_Z15nvshmem_iget128_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z15nvshmem_iget128_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z15nvshmem_iget128_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iget128, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmem_iget128_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmem_iget128_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z15nvshmem_iget128_nbst(shim_stream, shim_obj)


def short_test():
    pass
    

def _lower__Z18nvshmem_short_test_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_short_test_nbst(int &retval , short ** ivar, int* cmp, short* cmp_value) {
        retval = nvshmem_short_test(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z18nvshmem_short_test_nbst = declare_device(
        '_Z18nvshmem_short_test_nbst',
        int32(
            CPointer(CPointer(int16)), CPointer(int32), CPointer(int16)
        )
    )
    

    def _Z18nvshmem_short_test_nbst_caller(arg_0, arg_1, arg_2):
        return _Z18nvshmem_short_test_nbst(arg_0, arg_1, arg_2)
    

    @lower(short_test, CPointer(int16), int32, int16)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z18nvshmem_short_test_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_short_test_nbst_caller,
            signature(int32, CPointer(CPointer(int16)), CPointer(int32), CPointer(int16)),
            ptrs,
        )



_lower__Z18nvshmem_short_test_nbst(shim_stream, shim_obj)


def int_test():
    pass
    

def _lower__Z16nvshmem_int_test_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z16nvshmem_int_test_nbst(int &retval , int ** ivar, int* cmp, int* cmp_value) {
        retval = nvshmem_int_test(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z16nvshmem_int_test_nbst = declare_device(
        '_Z16nvshmem_int_test_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z16nvshmem_int_test_nbst_caller(arg_0, arg_1, arg_2):
        return _Z16nvshmem_int_test_nbst(arg_0, arg_1, arg_2)
    

    @lower(int_test, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z16nvshmem_int_test_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z16nvshmem_int_test_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z16nvshmem_int_test_nbst(shim_stream, shim_obj)


def long_test():
    pass
    

def _lower__Z17nvshmem_long_test_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_long_test_nbst(int &retval , long ** ivar, int* cmp, long* cmp_value) {
        retval = nvshmem_long_test(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z17nvshmem_long_test_nbst = declare_device(
        '_Z17nvshmem_long_test_nbst',
        int32(
            CPointer(CPointer(int64)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z17nvshmem_long_test_nbst_caller(arg_0, arg_1, arg_2):
        return _Z17nvshmem_long_test_nbst(arg_0, arg_1, arg_2)
    

    @lower(long_test, CPointer(int64), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z17nvshmem_long_test_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_long_test_nbst_caller,
            signature(int32, CPointer(CPointer(int64)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z17nvshmem_long_test_nbst(shim_stream, shim_obj)


def longlong_test():
    pass
    

def _lower__Z21nvshmem_longlong_test_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_longlong_test_nbst(int &retval , long long ** ivar, int* cmp, long long* cmp_value) {
        retval = nvshmem_longlong_test(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z21nvshmem_longlong_test_nbst = declare_device(
        '_Z21nvshmem_longlong_test_nbst',
        int32(
            CPointer(CPointer(int64)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z21nvshmem_longlong_test_nbst_caller(arg_0, arg_1, arg_2):
        return _Z21nvshmem_longlong_test_nbst(arg_0, arg_1, arg_2)
    

    @lower(longlong_test, CPointer(int64), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z21nvshmem_longlong_test_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_longlong_test_nbst_caller,
            signature(int32, CPointer(CPointer(int64)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z21nvshmem_longlong_test_nbst(shim_stream, shim_obj)


def ushort_test():
    pass
    

def _lower__Z19nvshmem_ushort_test_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_ushort_test_nbst(int &retval , unsigned short ** ivar, int* cmp, unsigned short* cmp_value) {
        retval = nvshmem_ushort_test(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z19nvshmem_ushort_test_nbst = declare_device(
        '_Z19nvshmem_ushort_test_nbst',
        int32(
            CPointer(CPointer(uint16)), CPointer(int32), CPointer(uint16)
        )
    )
    

    def _Z19nvshmem_ushort_test_nbst_caller(arg_0, arg_1, arg_2):
        return _Z19nvshmem_ushort_test_nbst(arg_0, arg_1, arg_2)
    

    @lower(ushort_test, CPointer(uint16), int32, uint16)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z19nvshmem_ushort_test_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_ushort_test_nbst_caller,
            signature(int32, CPointer(CPointer(uint16)), CPointer(int32), CPointer(uint16)),
            ptrs,
        )



_lower__Z19nvshmem_ushort_test_nbst(shim_stream, shim_obj)


def uint_test():
    pass
    

def _lower__Z17nvshmem_uint_test_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_uint_test_nbst(int &retval , unsigned int ** ivar, int* cmp, unsigned int* cmp_value) {
        retval = nvshmem_uint_test(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z17nvshmem_uint_test_nbst = declare_device(
        '_Z17nvshmem_uint_test_nbst',
        int32(
            CPointer(CPointer(uint32)), CPointer(int32), CPointer(uint32)
        )
    )
    

    def _Z17nvshmem_uint_test_nbst_caller(arg_0, arg_1, arg_2):
        return _Z17nvshmem_uint_test_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint_test, CPointer(uint32), int32, uint32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z17nvshmem_uint_test_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_uint_test_nbst_caller,
            signature(int32, CPointer(CPointer(uint32)), CPointer(int32), CPointer(uint32)),
            ptrs,
        )



_lower__Z17nvshmem_uint_test_nbst(shim_stream, shim_obj)


def ulong_test():
    pass
    

def _lower__Z18nvshmem_ulong_test_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_ulong_test_nbst(int &retval , unsigned long ** ivar, int* cmp, unsigned long* cmp_value) {
        retval = nvshmem_ulong_test(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z18nvshmem_ulong_test_nbst = declare_device(
        '_Z18nvshmem_ulong_test_nbst',
        int32(
            CPointer(CPointer(uint64)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z18nvshmem_ulong_test_nbst_caller(arg_0, arg_1, arg_2):
        return _Z18nvshmem_ulong_test_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulong_test, CPointer(uint64), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z18nvshmem_ulong_test_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_ulong_test_nbst_caller,
            signature(int32, CPointer(CPointer(uint64)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z18nvshmem_ulong_test_nbst(shim_stream, shim_obj)


def ulonglong_test():
    pass
    

def _lower__Z22nvshmem_ulonglong_test_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_ulonglong_test_nbst(int &retval , unsigned long long ** ivar, int* cmp, unsigned long long* cmp_value) {
        retval = nvshmem_ulonglong_test(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z22nvshmem_ulonglong_test_nbst = declare_device(
        '_Z22nvshmem_ulonglong_test_nbst',
        int32(
            CPointer(CPointer(uint64)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z22nvshmem_ulonglong_test_nbst_caller(arg_0, arg_1, arg_2):
        return _Z22nvshmem_ulonglong_test_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulonglong_test, CPointer(uint64), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z22nvshmem_ulonglong_test_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_ulonglong_test_nbst_caller,
            signature(int32, CPointer(CPointer(uint64)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z22nvshmem_ulonglong_test_nbst(shim_stream, shim_obj)


def int32_test():
    pass
    

def _lower__Z18nvshmem_int32_test_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_int32_test_nbst(int &retval , int32_t ** ivar, int* cmp, int32_t* cmp_value) {
        retval = nvshmem_int32_test(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z18nvshmem_int32_test_nbst = declare_device(
        '_Z18nvshmem_int32_test_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z18nvshmem_int32_test_nbst_caller(arg_0, arg_1, arg_2):
        return _Z18nvshmem_int32_test_nbst(arg_0, arg_1, arg_2)
    

    @lower(int32_test, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z18nvshmem_int32_test_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_int32_test_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmem_int32_test_nbst(shim_stream, shim_obj)


def int64_test():
    pass
    

def _lower__Z18nvshmem_int64_test_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmem_int64_test_nbst(int &retval , int64_t ** ivar, int* cmp, int64_t* cmp_value) {
        retval = nvshmem_int64_test(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z18nvshmem_int64_test_nbst = declare_device(
        '_Z18nvshmem_int64_test_nbst',
        int32(
            CPointer(CPointer(int64)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z18nvshmem_int64_test_nbst_caller(arg_0, arg_1, arg_2):
        return _Z18nvshmem_int64_test_nbst(arg_0, arg_1, arg_2)
    

    @lower(int64_test, CPointer(int64), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z18nvshmem_int64_test_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmem_int64_test_nbst_caller,
            signature(int32, CPointer(CPointer(int64)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z18nvshmem_int64_test_nbst(shim_stream, shim_obj)


def uint32_test():
    pass
    

def _lower__Z19nvshmem_uint32_test_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_uint32_test_nbst(int &retval , uint32_t ** ivar, int* cmp, uint32_t* cmp_value) {
        retval = nvshmem_uint32_test(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z19nvshmem_uint32_test_nbst = declare_device(
        '_Z19nvshmem_uint32_test_nbst',
        int32(
            CPointer(CPointer(uint32)), CPointer(int32), CPointer(uint32)
        )
    )
    

    def _Z19nvshmem_uint32_test_nbst_caller(arg_0, arg_1, arg_2):
        return _Z19nvshmem_uint32_test_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint32_test, CPointer(uint32), int32, uint32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z19nvshmem_uint32_test_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_uint32_test_nbst_caller,
            signature(int32, CPointer(CPointer(uint32)), CPointer(int32), CPointer(uint32)),
            ptrs,
        )



_lower__Z19nvshmem_uint32_test_nbst(shim_stream, shim_obj)


def uint64_test():
    pass
    

def _lower__Z19nvshmem_uint64_test_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmem_uint64_test_nbst(int &retval , uint64_t ** ivar, int* cmp, uint64_t* cmp_value) {
        retval = nvshmem_uint64_test(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z19nvshmem_uint64_test_nbst = declare_device(
        '_Z19nvshmem_uint64_test_nbst',
        int32(
            CPointer(CPointer(uint64)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z19nvshmem_uint64_test_nbst_caller(arg_0, arg_1, arg_2):
        return _Z19nvshmem_uint64_test_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint64_test, CPointer(uint64), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z19nvshmem_uint64_test_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmem_uint64_test_nbst_caller,
            signature(int32, CPointer(CPointer(uint64)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z19nvshmem_uint64_test_nbst(shim_stream, shim_obj)


def size_test():
    pass
    

def _lower__Z17nvshmem_size_test_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmem_size_test_nbst(int &retval , unsigned long ** ivar, int* cmp, unsigned long* cmp_value) {
        retval = nvshmem_size_test(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z17nvshmem_size_test_nbst = declare_device(
        '_Z17nvshmem_size_test_nbst',
        int32(
            CPointer(CPointer(uint64)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z17nvshmem_size_test_nbst_caller(arg_0, arg_1, arg_2):
        return _Z17nvshmem_size_test_nbst(arg_0, arg_1, arg_2)
    

    @lower(size_test, CPointer(uint64), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z17nvshmem_size_test_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmem_size_test_nbst_caller,
            signature(int32, CPointer(CPointer(uint64)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z17nvshmem_size_test_nbst(shim_stream, shim_obj)


def ptrdiff_test():
    pass
    

def _lower__Z20nvshmem_ptrdiff_test_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_ptrdiff_test_nbst(int &retval , long ** ivar, int* cmp, long* cmp_value) {
        retval = nvshmem_ptrdiff_test(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z20nvshmem_ptrdiff_test_nbst = declare_device(
        '_Z20nvshmem_ptrdiff_test_nbst',
        int32(
            CPointer(CPointer(int64)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z20nvshmem_ptrdiff_test_nbst_caller(arg_0, arg_1, arg_2):
        return _Z20nvshmem_ptrdiff_test_nbst(arg_0, arg_1, arg_2)
    

    @lower(ptrdiff_test, CPointer(int64), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z20nvshmem_ptrdiff_test_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_ptrdiff_test_nbst_caller,
            signature(int32, CPointer(CPointer(int64)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z20nvshmem_ptrdiff_test_nbst(shim_stream, shim_obj)


def short_test_all():
    pass
    

def _lower__Z22nvshmem_short_test_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_short_test_all_nbst(int &retval , short ** ivars, unsigned long* nelems, int ** status, int* cmp, short* cmp_value) {
        retval = nvshmem_short_test_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z22nvshmem_short_test_all_nbst = declare_device(
        '_Z22nvshmem_short_test_all_nbst',
        int32(
            CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int16)
        )
    )
    

    def _Z22nvshmem_short_test_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z22nvshmem_short_test_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(short_test_all, CPointer(int16), uint64, CPointer(int32), int32, int16)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z22nvshmem_short_test_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_short_test_all_nbst_caller,
            signature(int32, CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int16)),
            ptrs,
        )



_lower__Z22nvshmem_short_test_all_nbst(shim_stream, shim_obj)


def int_test_all():
    pass
    

def _lower__Z20nvshmem_int_test_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_int_test_all_nbst(int &retval , int ** ivars, unsigned long* nelems, int ** status, int* cmp, int* cmp_value) {
        retval = nvshmem_int_test_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z20nvshmem_int_test_all_nbst = declare_device(
        '_Z20nvshmem_int_test_all_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_int_test_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z20nvshmem_int_test_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int_test_all, CPointer(int32), uint64, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z20nvshmem_int_test_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_int_test_all_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_int_test_all_nbst(shim_stream, shim_obj)


def long_test_all():
    pass
    

def _lower__Z21nvshmem_long_test_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_long_test_all_nbst(int &retval , long ** ivars, unsigned long* nelems, int ** status, int* cmp, long* cmp_value) {
        retval = nvshmem_long_test_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z21nvshmem_long_test_all_nbst = declare_device(
        '_Z21nvshmem_long_test_all_nbst',
        int32(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z21nvshmem_long_test_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmem_long_test_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(long_test_all, CPointer(int64), uint64, CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z21nvshmem_long_test_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_long_test_all_nbst_caller,
            signature(int32, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z21nvshmem_long_test_all_nbst(shim_stream, shim_obj)


def longlong_test_all():
    pass
    

def _lower__Z25nvshmem_longlong_test_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_longlong_test_all_nbst(int &retval , long long ** ivars, unsigned long* nelems, int ** status, int* cmp, long long* cmp_value) {
        retval = nvshmem_longlong_test_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z25nvshmem_longlong_test_all_nbst = declare_device(
        '_Z25nvshmem_longlong_test_all_nbst',
        int32(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z25nvshmem_longlong_test_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmem_longlong_test_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(longlong_test_all, CPointer(int64), uint64, CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z25nvshmem_longlong_test_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_longlong_test_all_nbst_caller,
            signature(int32, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z25nvshmem_longlong_test_all_nbst(shim_stream, shim_obj)


def ushort_test_all():
    pass
    

def _lower__Z23nvshmem_ushort_test_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_ushort_test_all_nbst(int &retval , unsigned short ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned short* cmp_value) {
        retval = nvshmem_ushort_test_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z23nvshmem_ushort_test_all_nbst = declare_device(
        '_Z23nvshmem_ushort_test_all_nbst',
        int32(
            CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint16)
        )
    )
    

    def _Z23nvshmem_ushort_test_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z23nvshmem_ushort_test_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ushort_test_all, CPointer(uint16), uint64, CPointer(int32), int32, uint16)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z23nvshmem_ushort_test_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_ushort_test_all_nbst_caller,
            signature(int32, CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint16)),
            ptrs,
        )



_lower__Z23nvshmem_ushort_test_all_nbst(shim_stream, shim_obj)


def uint_test_all():
    pass
    

def _lower__Z21nvshmem_uint_test_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_uint_test_all_nbst(int &retval , unsigned int ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned int* cmp_value) {
        retval = nvshmem_uint_test_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z21nvshmem_uint_test_all_nbst = declare_device(
        '_Z21nvshmem_uint_test_all_nbst',
        int32(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)
        )
    )
    

    def _Z21nvshmem_uint_test_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmem_uint_test_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint_test_all, CPointer(uint32), uint64, CPointer(int32), int32, uint32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z21nvshmem_uint_test_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_uint_test_all_nbst_caller,
            signature(int32, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)),
            ptrs,
        )



_lower__Z21nvshmem_uint_test_all_nbst(shim_stream, shim_obj)


def ulong_test_all():
    pass
    

def _lower__Z22nvshmem_ulong_test_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_ulong_test_all_nbst(int &retval , unsigned long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long* cmp_value) {
        retval = nvshmem_ulong_test_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z22nvshmem_ulong_test_all_nbst = declare_device(
        '_Z22nvshmem_ulong_test_all_nbst',
        int32(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z22nvshmem_ulong_test_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z22nvshmem_ulong_test_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulong_test_all, CPointer(uint64), uint64, CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z22nvshmem_ulong_test_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_ulong_test_all_nbst_caller,
            signature(int32, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z22nvshmem_ulong_test_all_nbst(shim_stream, shim_obj)


def ulonglong_test_all():
    pass
    

def _lower__Z26nvshmem_ulonglong_test_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmem_ulonglong_test_all_nbst(int &retval , unsigned long long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long long* cmp_value) {
        retval = nvshmem_ulonglong_test_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z26nvshmem_ulonglong_test_all_nbst = declare_device(
        '_Z26nvshmem_ulonglong_test_all_nbst',
        int32(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z26nvshmem_ulonglong_test_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmem_ulonglong_test_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulonglong_test_all, CPointer(uint64), uint64, CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z26nvshmem_ulonglong_test_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmem_ulonglong_test_all_nbst_caller,
            signature(int32, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z26nvshmem_ulonglong_test_all_nbst(shim_stream, shim_obj)


def int32_test_all():
    pass
    

def _lower__Z22nvshmem_int32_test_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_int32_test_all_nbst(int &retval , int32_t ** ivars, unsigned long* nelems, int ** status, int* cmp, int32_t* cmp_value) {
        retval = nvshmem_int32_test_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z22nvshmem_int32_test_all_nbst = declare_device(
        '_Z22nvshmem_int32_test_all_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_int32_test_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z22nvshmem_int32_test_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int32_test_all, CPointer(int32), uint64, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z22nvshmem_int32_test_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_int32_test_all_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_int32_test_all_nbst(shim_stream, shim_obj)


def int64_test_all():
    pass
    

def _lower__Z22nvshmem_int64_test_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_int64_test_all_nbst(int &retval , int64_t ** ivars, unsigned long* nelems, int ** status, int* cmp, int64_t* cmp_value) {
        retval = nvshmem_int64_test_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z22nvshmem_int64_test_all_nbst = declare_device(
        '_Z22nvshmem_int64_test_all_nbst',
        int32(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z22nvshmem_int64_test_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z22nvshmem_int64_test_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int64_test_all, CPointer(int64), uint64, CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z22nvshmem_int64_test_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_int64_test_all_nbst_caller,
            signature(int32, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z22nvshmem_int64_test_all_nbst(shim_stream, shim_obj)


def uint32_test_all():
    pass
    

def _lower__Z23nvshmem_uint32_test_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_uint32_test_all_nbst(int &retval , uint32_t ** ivars, unsigned long* nelems, int ** status, int* cmp, uint32_t* cmp_value) {
        retval = nvshmem_uint32_test_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z23nvshmem_uint32_test_all_nbst = declare_device(
        '_Z23nvshmem_uint32_test_all_nbst',
        int32(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)
        )
    )
    

    def _Z23nvshmem_uint32_test_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z23nvshmem_uint32_test_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint32_test_all, CPointer(uint32), uint64, CPointer(int32), int32, uint32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z23nvshmem_uint32_test_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_uint32_test_all_nbst_caller,
            signature(int32, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)),
            ptrs,
        )



_lower__Z23nvshmem_uint32_test_all_nbst(shim_stream, shim_obj)


def uint64_test_all():
    pass
    

def _lower__Z23nvshmem_uint64_test_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_uint64_test_all_nbst(int &retval , uint64_t ** ivars, unsigned long* nelems, int ** status, int* cmp, uint64_t* cmp_value) {
        retval = nvshmem_uint64_test_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z23nvshmem_uint64_test_all_nbst = declare_device(
        '_Z23nvshmem_uint64_test_all_nbst',
        int32(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z23nvshmem_uint64_test_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z23nvshmem_uint64_test_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint64_test_all, CPointer(uint64), uint64, CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z23nvshmem_uint64_test_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_uint64_test_all_nbst_caller,
            signature(int32, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z23nvshmem_uint64_test_all_nbst(shim_stream, shim_obj)


def size_test_all():
    pass
    

def _lower__Z21nvshmem_size_test_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_size_test_all_nbst(int &retval , unsigned long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long* cmp_value) {
        retval = nvshmem_size_test_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z21nvshmem_size_test_all_nbst = declare_device(
        '_Z21nvshmem_size_test_all_nbst',
        int32(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z21nvshmem_size_test_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmem_size_test_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(size_test_all, CPointer(uint64), uint64, CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z21nvshmem_size_test_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_size_test_all_nbst_caller,
            signature(int32, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z21nvshmem_size_test_all_nbst(shim_stream, shim_obj)


def ptrdiff_test_all():
    pass
    

def _lower__Z24nvshmem_ptrdiff_test_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_ptrdiff_test_all_nbst(int &retval , long ** ivars, unsigned long* nelems, int ** status, int* cmp, long* cmp_value) {
        retval = nvshmem_ptrdiff_test_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z24nvshmem_ptrdiff_test_all_nbst = declare_device(
        '_Z24nvshmem_ptrdiff_test_all_nbst',
        int32(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z24nvshmem_ptrdiff_test_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmem_ptrdiff_test_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ptrdiff_test_all, CPointer(int64), uint64, CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z24nvshmem_ptrdiff_test_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_ptrdiff_test_all_nbst_caller,
            signature(int32, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z24nvshmem_ptrdiff_test_all_nbst(shim_stream, shim_obj)


def short_test_any():
    pass
    

def _lower__Z22nvshmem_short_test_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_short_test_any_nbst(unsigned long &retval , short ** ivars, unsigned long* nelems, int ** status, int* cmp, short* cmp_value) {
        retval = nvshmem_short_test_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z22nvshmem_short_test_any_nbst = declare_device(
        '_Z22nvshmem_short_test_any_nbst',
        uint64(
            CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int16)
        )
    )
    

    def _Z22nvshmem_short_test_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z22nvshmem_short_test_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(short_test_any, CPointer(int16), uint64, CPointer(int32), int32, int16)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z22nvshmem_short_test_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_short_test_any_nbst_caller,
            signature(uint64, CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int16)),
            ptrs,
        )



_lower__Z22nvshmem_short_test_any_nbst(shim_stream, shim_obj)


def int_test_any():
    pass
    

def _lower__Z20nvshmem_int_test_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_int_test_any_nbst(unsigned long &retval , int ** ivars, unsigned long* nelems, int ** status, int* cmp, int* cmp_value) {
        retval = nvshmem_int_test_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z20nvshmem_int_test_any_nbst = declare_device(
        '_Z20nvshmem_int_test_any_nbst',
        uint64(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmem_int_test_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z20nvshmem_int_test_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int_test_any, CPointer(int32), uint64, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z20nvshmem_int_test_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_int_test_any_nbst_caller,
            signature(uint64, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmem_int_test_any_nbst(shim_stream, shim_obj)


def long_test_any():
    pass
    

def _lower__Z21nvshmem_long_test_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_long_test_any_nbst(unsigned long &retval , long ** ivars, unsigned long* nelems, int ** status, int* cmp, long* cmp_value) {
        retval = nvshmem_long_test_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z21nvshmem_long_test_any_nbst = declare_device(
        '_Z21nvshmem_long_test_any_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z21nvshmem_long_test_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmem_long_test_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(long_test_any, CPointer(int64), uint64, CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z21nvshmem_long_test_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_long_test_any_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z21nvshmem_long_test_any_nbst(shim_stream, shim_obj)


def longlong_test_any():
    pass
    

def _lower__Z25nvshmem_longlong_test_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_longlong_test_any_nbst(unsigned long &retval , long long ** ivars, unsigned long* nelems, int ** status, int* cmp, long long* cmp_value) {
        retval = nvshmem_longlong_test_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z25nvshmem_longlong_test_any_nbst = declare_device(
        '_Z25nvshmem_longlong_test_any_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z25nvshmem_longlong_test_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmem_longlong_test_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(longlong_test_any, CPointer(int64), uint64, CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z25nvshmem_longlong_test_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_longlong_test_any_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z25nvshmem_longlong_test_any_nbst(shim_stream, shim_obj)


def ushort_test_any():
    pass
    

def _lower__Z23nvshmem_ushort_test_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_ushort_test_any_nbst(unsigned long &retval , unsigned short ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned short* cmp_value) {
        retval = nvshmem_ushort_test_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z23nvshmem_ushort_test_any_nbst = declare_device(
        '_Z23nvshmem_ushort_test_any_nbst',
        uint64(
            CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint16)
        )
    )
    

    def _Z23nvshmem_ushort_test_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z23nvshmem_ushort_test_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ushort_test_any, CPointer(uint16), uint64, CPointer(int32), int32, uint16)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z23nvshmem_ushort_test_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_ushort_test_any_nbst_caller,
            signature(uint64, CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint16)),
            ptrs,
        )



_lower__Z23nvshmem_ushort_test_any_nbst(shim_stream, shim_obj)


def uint_test_any():
    pass
    

def _lower__Z21nvshmem_uint_test_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_uint_test_any_nbst(unsigned long &retval , unsigned int ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned int* cmp_value) {
        retval = nvshmem_uint_test_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z21nvshmem_uint_test_any_nbst = declare_device(
        '_Z21nvshmem_uint_test_any_nbst',
        uint64(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)
        )
    )
    

    def _Z21nvshmem_uint_test_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmem_uint_test_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint_test_any, CPointer(uint32), uint64, CPointer(int32), int32, uint32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z21nvshmem_uint_test_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_uint_test_any_nbst_caller,
            signature(uint64, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)),
            ptrs,
        )



_lower__Z21nvshmem_uint_test_any_nbst(shim_stream, shim_obj)


def ulong_test_any():
    pass
    

def _lower__Z22nvshmem_ulong_test_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_ulong_test_any_nbst(unsigned long &retval , unsigned long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long* cmp_value) {
        retval = nvshmem_ulong_test_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z22nvshmem_ulong_test_any_nbst = declare_device(
        '_Z22nvshmem_ulong_test_any_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z22nvshmem_ulong_test_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z22nvshmem_ulong_test_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulong_test_any, CPointer(uint64), uint64, CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z22nvshmem_ulong_test_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_ulong_test_any_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z22nvshmem_ulong_test_any_nbst(shim_stream, shim_obj)


def ulonglong_test_any():
    pass
    

def _lower__Z26nvshmem_ulonglong_test_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmem_ulonglong_test_any_nbst(unsigned long &retval , unsigned long long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long long* cmp_value) {
        retval = nvshmem_ulonglong_test_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z26nvshmem_ulonglong_test_any_nbst = declare_device(
        '_Z26nvshmem_ulonglong_test_any_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z26nvshmem_ulonglong_test_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmem_ulonglong_test_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulonglong_test_any, CPointer(uint64), uint64, CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z26nvshmem_ulonglong_test_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmem_ulonglong_test_any_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z26nvshmem_ulonglong_test_any_nbst(shim_stream, shim_obj)


def int32_test_any():
    pass
    

def _lower__Z22nvshmem_int32_test_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_int32_test_any_nbst(unsigned long &retval , int32_t ** ivars, unsigned long* nelems, int ** status, int* cmp, int32_t* cmp_value) {
        retval = nvshmem_int32_test_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z22nvshmem_int32_test_any_nbst = declare_device(
        '_Z22nvshmem_int32_test_any_nbst',
        uint64(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_int32_test_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z22nvshmem_int32_test_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int32_test_any, CPointer(int32), uint64, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z22nvshmem_int32_test_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_int32_test_any_nbst_caller,
            signature(uint64, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_int32_test_any_nbst(shim_stream, shim_obj)


def int64_test_any():
    pass
    

def _lower__Z22nvshmem_int64_test_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_int64_test_any_nbst(unsigned long &retval , int64_t ** ivars, unsigned long* nelems, int ** status, int* cmp, int64_t* cmp_value) {
        retval = nvshmem_int64_test_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z22nvshmem_int64_test_any_nbst = declare_device(
        '_Z22nvshmem_int64_test_any_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z22nvshmem_int64_test_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z22nvshmem_int64_test_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int64_test_any, CPointer(int64), uint64, CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z22nvshmem_int64_test_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_int64_test_any_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z22nvshmem_int64_test_any_nbst(shim_stream, shim_obj)


def uint32_test_any():
    pass
    

def _lower__Z23nvshmem_uint32_test_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_uint32_test_any_nbst(unsigned long &retval , uint32_t ** ivars, unsigned long* nelems, int ** status, int* cmp, uint32_t* cmp_value) {
        retval = nvshmem_uint32_test_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z23nvshmem_uint32_test_any_nbst = declare_device(
        '_Z23nvshmem_uint32_test_any_nbst',
        uint64(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)
        )
    )
    

    def _Z23nvshmem_uint32_test_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z23nvshmem_uint32_test_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint32_test_any, CPointer(uint32), uint64, CPointer(int32), int32, uint32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z23nvshmem_uint32_test_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_uint32_test_any_nbst_caller,
            signature(uint64, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)),
            ptrs,
        )



_lower__Z23nvshmem_uint32_test_any_nbst(shim_stream, shim_obj)


def uint64_test_any():
    pass
    

def _lower__Z23nvshmem_uint64_test_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_uint64_test_any_nbst(unsigned long &retval , uint64_t ** ivars, unsigned long* nelems, int ** status, int* cmp, uint64_t* cmp_value) {
        retval = nvshmem_uint64_test_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z23nvshmem_uint64_test_any_nbst = declare_device(
        '_Z23nvshmem_uint64_test_any_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z23nvshmem_uint64_test_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z23nvshmem_uint64_test_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint64_test_any, CPointer(uint64), uint64, CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z23nvshmem_uint64_test_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_uint64_test_any_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z23nvshmem_uint64_test_any_nbst(shim_stream, shim_obj)


def size_test_any():
    pass
    

def _lower__Z21nvshmem_size_test_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_size_test_any_nbst(unsigned long &retval , unsigned long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long* cmp_value) {
        retval = nvshmem_size_test_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z21nvshmem_size_test_any_nbst = declare_device(
        '_Z21nvshmem_size_test_any_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z21nvshmem_size_test_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmem_size_test_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(size_test_any, CPointer(uint64), uint64, CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z21nvshmem_size_test_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_size_test_any_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z21nvshmem_size_test_any_nbst(shim_stream, shim_obj)


def ptrdiff_test_any():
    pass
    

def _lower__Z24nvshmem_ptrdiff_test_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_ptrdiff_test_any_nbst(unsigned long &retval , long ** ivars, unsigned long* nelems, int ** status, int* cmp, long* cmp_value) {
        retval = nvshmem_ptrdiff_test_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z24nvshmem_ptrdiff_test_any_nbst = declare_device(
        '_Z24nvshmem_ptrdiff_test_any_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z24nvshmem_ptrdiff_test_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmem_ptrdiff_test_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ptrdiff_test_any, CPointer(int64), uint64, CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z24nvshmem_ptrdiff_test_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_ptrdiff_test_any_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z24nvshmem_ptrdiff_test_any_nbst(shim_stream, shim_obj)


def short_test_some():
    pass
    

def _lower__Z23nvshmem_short_test_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_short_test_some_nbst(unsigned long &retval , short ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, short* cmp_value) {
        retval = nvshmem_short_test_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z23nvshmem_short_test_some_nbst = declare_device(
        '_Z23nvshmem_short_test_some_nbst',
        uint64(
            CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int16)
        )
    )
    

    def _Z23nvshmem_short_test_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z23nvshmem_short_test_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(short_test_some, CPointer(int16), uint64, CPointer(uint64), CPointer(int32), int32, int16)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z23nvshmem_short_test_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_short_test_some_nbst_caller,
            signature(uint64, CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int16)),
            ptrs,
        )



_lower__Z23nvshmem_short_test_some_nbst(shim_stream, shim_obj)


def int_test_some():
    pass
    

def _lower__Z21nvshmem_int_test_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmem_int_test_some_nbst(unsigned long &retval , int ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, int* cmp_value) {
        retval = nvshmem_int_test_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z21nvshmem_int_test_some_nbst = declare_device(
        '_Z21nvshmem_int_test_some_nbst',
        uint64(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmem_int_test_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z21nvshmem_int_test_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int_test_some, CPointer(int32), uint64, CPointer(uint64), CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z21nvshmem_int_test_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmem_int_test_some_nbst_caller,
            signature(uint64, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmem_int_test_some_nbst(shim_stream, shim_obj)


def long_test_some():
    pass
    

def _lower__Z22nvshmem_long_test_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_long_test_some_nbst(unsigned long &retval , long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, long* cmp_value) {
        retval = nvshmem_long_test_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z22nvshmem_long_test_some_nbst = declare_device(
        '_Z22nvshmem_long_test_some_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z22nvshmem_long_test_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z22nvshmem_long_test_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(long_test_some, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z22nvshmem_long_test_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_long_test_some_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z22nvshmem_long_test_some_nbst(shim_stream, shim_obj)


def longlong_test_some():
    pass
    

def _lower__Z26nvshmem_longlong_test_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmem_longlong_test_some_nbst(unsigned long &retval , long long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, long long* cmp_value) {
        retval = nvshmem_longlong_test_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z26nvshmem_longlong_test_some_nbst = declare_device(
        '_Z26nvshmem_longlong_test_some_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z26nvshmem_longlong_test_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z26nvshmem_longlong_test_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(longlong_test_some, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z26nvshmem_longlong_test_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmem_longlong_test_some_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z26nvshmem_longlong_test_some_nbst(shim_stream, shim_obj)


def ushort_test_some():
    pass
    

def _lower__Z24nvshmem_ushort_test_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_ushort_test_some_nbst(unsigned long &retval , unsigned short ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned short* cmp_value) {
        retval = nvshmem_ushort_test_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z24nvshmem_ushort_test_some_nbst = declare_device(
        '_Z24nvshmem_ushort_test_some_nbst',
        uint64(
            CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint16)
        )
    )
    

    def _Z24nvshmem_ushort_test_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmem_ushort_test_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ushort_test_some, CPointer(uint16), uint64, CPointer(uint64), CPointer(int32), int32, uint16)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z24nvshmem_ushort_test_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_ushort_test_some_nbst_caller,
            signature(uint64, CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint16)),
            ptrs,
        )



_lower__Z24nvshmem_ushort_test_some_nbst(shim_stream, shim_obj)


def uint_test_some():
    pass
    

def _lower__Z22nvshmem_uint_test_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_uint_test_some_nbst(unsigned long &retval , unsigned int ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned int* cmp_value) {
        retval = nvshmem_uint_test_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z22nvshmem_uint_test_some_nbst = declare_device(
        '_Z22nvshmem_uint_test_some_nbst',
        uint64(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)
        )
    )
    

    def _Z22nvshmem_uint_test_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z22nvshmem_uint_test_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint_test_some, CPointer(uint32), uint64, CPointer(uint64), CPointer(int32), int32, uint32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z22nvshmem_uint_test_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_uint_test_some_nbst_caller,
            signature(uint64, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)),
            ptrs,
        )



_lower__Z22nvshmem_uint_test_some_nbst(shim_stream, shim_obj)


def ulong_test_some():
    pass
    

def _lower__Z23nvshmem_ulong_test_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_ulong_test_some_nbst(unsigned long &retval , unsigned long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned long* cmp_value) {
        retval = nvshmem_ulong_test_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z23nvshmem_ulong_test_some_nbst = declare_device(
        '_Z23nvshmem_ulong_test_some_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z23nvshmem_ulong_test_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z23nvshmem_ulong_test_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulong_test_some, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z23nvshmem_ulong_test_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_ulong_test_some_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z23nvshmem_ulong_test_some_nbst(shim_stream, shim_obj)


def ulonglong_test_some():
    pass
    

def _lower__Z27nvshmem_ulonglong_test_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_ulonglong_test_some_nbst(unsigned long &retval , unsigned long long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned long long* cmp_value) {
        retval = nvshmem_ulonglong_test_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z27nvshmem_ulonglong_test_some_nbst = declare_device(
        '_Z27nvshmem_ulonglong_test_some_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z27nvshmem_ulonglong_test_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z27nvshmem_ulonglong_test_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulonglong_test_some, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z27nvshmem_ulonglong_test_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_ulonglong_test_some_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z27nvshmem_ulonglong_test_some_nbst(shim_stream, shim_obj)


def int32_test_some():
    pass
    

def _lower__Z23nvshmem_int32_test_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_int32_test_some_nbst(unsigned long &retval , int32_t ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, int32_t* cmp_value) {
        retval = nvshmem_int32_test_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z23nvshmem_int32_test_some_nbst = declare_device(
        '_Z23nvshmem_int32_test_some_nbst',
        uint64(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_int32_test_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z23nvshmem_int32_test_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int32_test_some, CPointer(int32), uint64, CPointer(uint64), CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z23nvshmem_int32_test_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_int32_test_some_nbst_caller,
            signature(uint64, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_int32_test_some_nbst(shim_stream, shim_obj)


def int64_test_some():
    pass
    

def _lower__Z23nvshmem_int64_test_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_int64_test_some_nbst(unsigned long &retval , int64_t ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, int64_t* cmp_value) {
        retval = nvshmem_int64_test_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z23nvshmem_int64_test_some_nbst = declare_device(
        '_Z23nvshmem_int64_test_some_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z23nvshmem_int64_test_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z23nvshmem_int64_test_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int64_test_some, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z23nvshmem_int64_test_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_int64_test_some_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z23nvshmem_int64_test_some_nbst(shim_stream, shim_obj)


def uint32_test_some():
    pass
    

def _lower__Z24nvshmem_uint32_test_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_uint32_test_some_nbst(unsigned long &retval , uint32_t ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, uint32_t* cmp_value) {
        retval = nvshmem_uint32_test_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z24nvshmem_uint32_test_some_nbst = declare_device(
        '_Z24nvshmem_uint32_test_some_nbst',
        uint64(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)
        )
    )
    

    def _Z24nvshmem_uint32_test_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmem_uint32_test_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint32_test_some, CPointer(uint32), uint64, CPointer(uint64), CPointer(int32), int32, uint32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z24nvshmem_uint32_test_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_uint32_test_some_nbst_caller,
            signature(uint64, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)),
            ptrs,
        )



_lower__Z24nvshmem_uint32_test_some_nbst(shim_stream, shim_obj)


def uint64_test_some():
    pass
    

def _lower__Z24nvshmem_uint64_test_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_uint64_test_some_nbst(unsigned long &retval , uint64_t ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, uint64_t* cmp_value) {
        retval = nvshmem_uint64_test_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z24nvshmem_uint64_test_some_nbst = declare_device(
        '_Z24nvshmem_uint64_test_some_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z24nvshmem_uint64_test_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmem_uint64_test_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint64_test_some, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z24nvshmem_uint64_test_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_uint64_test_some_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z24nvshmem_uint64_test_some_nbst(shim_stream, shim_obj)


def size_test_some():
    pass
    

def _lower__Z22nvshmem_size_test_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_size_test_some_nbst(unsigned long &retval , unsigned long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned long* cmp_value) {
        retval = nvshmem_size_test_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z22nvshmem_size_test_some_nbst = declare_device(
        '_Z22nvshmem_size_test_some_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z22nvshmem_size_test_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z22nvshmem_size_test_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(size_test_some, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z22nvshmem_size_test_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_size_test_some_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z22nvshmem_size_test_some_nbst(shim_stream, shim_obj)


def ptrdiff_test_some():
    pass
    

def _lower__Z25nvshmem_ptrdiff_test_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_ptrdiff_test_some_nbst(unsigned long &retval , long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, long* cmp_value) {
        retval = nvshmem_ptrdiff_test_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z25nvshmem_ptrdiff_test_some_nbst = declare_device(
        '_Z25nvshmem_ptrdiff_test_some_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z25nvshmem_ptrdiff_test_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmem_ptrdiff_test_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ptrdiff_test_some, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z25nvshmem_ptrdiff_test_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_ptrdiff_test_some_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z25nvshmem_ptrdiff_test_some_nbst(shim_stream, shim_obj)


def short_test_all_vector():
    pass
    

def _lower__Z29nvshmem_short_test_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_short_test_all_vector_nbst(int &retval , short ** ivars, unsigned long* nelems, int ** status, int* cmp, short ** cmp_value) {
        retval = nvshmem_short_test_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_short_test_all_vector_nbst = declare_device(
        '_Z29nvshmem_short_test_all_vector_nbst',
        int32(
            CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int16))
        )
    )
    

    def _Z29nvshmem_short_test_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmem_short_test_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(short_test_all_vector, CPointer(int16), uint64, CPointer(int32), int32, CPointer(int16))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_short_test_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_short_test_all_vector_nbst_caller,
            signature(int32, CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int16))),
            ptrs,
        )



_lower__Z29nvshmem_short_test_all_vector_nbst(shim_stream, shim_obj)


def int_test_all_vector():
    pass
    

def _lower__Z27nvshmem_int_test_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_int_test_all_vector_nbst(int &retval , int ** ivars, unsigned long* nelems, int ** status, int* cmp, int ** cmp_value) {
        retval = nvshmem_int_test_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z27nvshmem_int_test_all_vector_nbst = declare_device(
        '_Z27nvshmem_int_test_all_vector_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))
        )
    )
    

    def _Z27nvshmem_int_test_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmem_int_test_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int_test_all_vector, CPointer(int32), uint64, CPointer(int32), int32, CPointer(int32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z27nvshmem_int_test_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_int_test_all_vector_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))),
            ptrs,
        )



_lower__Z27nvshmem_int_test_all_vector_nbst(shim_stream, shim_obj)


def long_test_all_vector():
    pass
    

def _lower__Z28nvshmem_long_test_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_long_test_all_vector_nbst(int &retval , long ** ivars, unsigned long* nelems, int ** status, int* cmp, long ** cmp_value) {
        retval = nvshmem_long_test_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z28nvshmem_long_test_all_vector_nbst = declare_device(
        '_Z28nvshmem_long_test_all_vector_nbst',
        int32(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z28nvshmem_long_test_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmem_long_test_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(long_test_all_vector, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z28nvshmem_long_test_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_long_test_all_vector_nbst_caller,
            signature(int32, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z28nvshmem_long_test_all_vector_nbst(shim_stream, shim_obj)


def longlong_test_all_vector():
    pass
    

def _lower__Z32nvshmem_longlong_test_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmem_longlong_test_all_vector_nbst(int &retval , long long ** ivars, unsigned long* nelems, int ** status, int* cmp, long long ** cmp_value) {
        retval = nvshmem_longlong_test_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z32nvshmem_longlong_test_all_vector_nbst = declare_device(
        '_Z32nvshmem_longlong_test_all_vector_nbst',
        int32(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z32nvshmem_longlong_test_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z32nvshmem_longlong_test_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(longlong_test_all_vector, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z32nvshmem_longlong_test_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmem_longlong_test_all_vector_nbst_caller,
            signature(int32, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z32nvshmem_longlong_test_all_vector_nbst(shim_stream, shim_obj)


def ushort_test_all_vector():
    pass
    

def _lower__Z30nvshmem_ushort_test_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_ushort_test_all_vector_nbst(int &retval , unsigned short ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned short ** cmp_value) {
        retval = nvshmem_ushort_test_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z30nvshmem_ushort_test_all_vector_nbst = declare_device(
        '_Z30nvshmem_ushort_test_all_vector_nbst',
        int32(
            CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint16))
        )
    )
    

    def _Z30nvshmem_ushort_test_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmem_ushort_test_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ushort_test_all_vector, CPointer(uint16), uint64, CPointer(int32), int32, CPointer(uint16))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z30nvshmem_ushort_test_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_ushort_test_all_vector_nbst_caller,
            signature(int32, CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint16))),
            ptrs,
        )



_lower__Z30nvshmem_ushort_test_all_vector_nbst(shim_stream, shim_obj)


def uint_test_all_vector():
    pass
    

def _lower__Z28nvshmem_uint_test_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_uint_test_all_vector_nbst(int &retval , unsigned int ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned int ** cmp_value) {
        retval = nvshmem_uint_test_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z28nvshmem_uint_test_all_vector_nbst = declare_device(
        '_Z28nvshmem_uint_test_all_vector_nbst',
        int32(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))
        )
    )
    

    def _Z28nvshmem_uint_test_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmem_uint_test_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint_test_all_vector, CPointer(uint32), uint64, CPointer(int32), int32, CPointer(uint32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z28nvshmem_uint_test_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_uint_test_all_vector_nbst_caller,
            signature(int32, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))),
            ptrs,
        )



_lower__Z28nvshmem_uint_test_all_vector_nbst(shim_stream, shim_obj)


def ulong_test_all_vector():
    pass
    

def _lower__Z29nvshmem_ulong_test_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_ulong_test_all_vector_nbst(int &retval , unsigned long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long ** cmp_value) {
        retval = nvshmem_ulong_test_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_ulong_test_all_vector_nbst = declare_device(
        '_Z29nvshmem_ulong_test_all_vector_nbst',
        int32(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z29nvshmem_ulong_test_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmem_ulong_test_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulong_test_all_vector, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_ulong_test_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_ulong_test_all_vector_nbst_caller,
            signature(int32, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z29nvshmem_ulong_test_all_vector_nbst(shim_stream, shim_obj)


def ulonglong_test_all_vector():
    pass
    

def _lower__Z33nvshmem_ulonglong_test_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmem_ulonglong_test_all_vector_nbst(int &retval , unsigned long long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long long ** cmp_value) {
        retval = nvshmem_ulonglong_test_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z33nvshmem_ulonglong_test_all_vector_nbst = declare_device(
        '_Z33nvshmem_ulonglong_test_all_vector_nbst',
        int32(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z33nvshmem_ulonglong_test_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z33nvshmem_ulonglong_test_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulonglong_test_all_vector, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z33nvshmem_ulonglong_test_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmem_ulonglong_test_all_vector_nbst_caller,
            signature(int32, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z33nvshmem_ulonglong_test_all_vector_nbst(shim_stream, shim_obj)


def int32_test_all_vector():
    pass
    

def _lower__Z29nvshmem_int32_test_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_int32_test_all_vector_nbst(int &retval , int32_t ** ivars, unsigned long* nelems, int ** status, int* cmp, int32_t ** cmp_value) {
        retval = nvshmem_int32_test_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_int32_test_all_vector_nbst = declare_device(
        '_Z29nvshmem_int32_test_all_vector_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))
        )
    )
    

    def _Z29nvshmem_int32_test_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmem_int32_test_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int32_test_all_vector, CPointer(int32), uint64, CPointer(int32), int32, CPointer(int32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_int32_test_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_int32_test_all_vector_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))),
            ptrs,
        )



_lower__Z29nvshmem_int32_test_all_vector_nbst(shim_stream, shim_obj)


def int64_test_all_vector():
    pass
    

def _lower__Z29nvshmem_int64_test_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_int64_test_all_vector_nbst(int &retval , int64_t ** ivars, unsigned long* nelems, int ** status, int* cmp, int64_t ** cmp_value) {
        retval = nvshmem_int64_test_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_int64_test_all_vector_nbst = declare_device(
        '_Z29nvshmem_int64_test_all_vector_nbst',
        int32(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z29nvshmem_int64_test_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmem_int64_test_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int64_test_all_vector, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_int64_test_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_int64_test_all_vector_nbst_caller,
            signature(int32, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z29nvshmem_int64_test_all_vector_nbst(shim_stream, shim_obj)


def uint32_test_all_vector():
    pass
    

def _lower__Z30nvshmem_uint32_test_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_uint32_test_all_vector_nbst(int &retval , uint32_t ** ivars, unsigned long* nelems, int ** status, int* cmp, uint32_t ** cmp_value) {
        retval = nvshmem_uint32_test_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z30nvshmem_uint32_test_all_vector_nbst = declare_device(
        '_Z30nvshmem_uint32_test_all_vector_nbst',
        int32(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))
        )
    )
    

    def _Z30nvshmem_uint32_test_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmem_uint32_test_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint32_test_all_vector, CPointer(uint32), uint64, CPointer(int32), int32, CPointer(uint32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z30nvshmem_uint32_test_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_uint32_test_all_vector_nbst_caller,
            signature(int32, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))),
            ptrs,
        )



_lower__Z30nvshmem_uint32_test_all_vector_nbst(shim_stream, shim_obj)


def uint64_test_all_vector():
    pass
    

def _lower__Z30nvshmem_uint64_test_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_uint64_test_all_vector_nbst(int &retval , uint64_t ** ivars, unsigned long* nelems, int ** status, int* cmp, uint64_t ** cmp_value) {
        retval = nvshmem_uint64_test_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z30nvshmem_uint64_test_all_vector_nbst = declare_device(
        '_Z30nvshmem_uint64_test_all_vector_nbst',
        int32(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z30nvshmem_uint64_test_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmem_uint64_test_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint64_test_all_vector, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z30nvshmem_uint64_test_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_uint64_test_all_vector_nbst_caller,
            signature(int32, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z30nvshmem_uint64_test_all_vector_nbst(shim_stream, shim_obj)


def size_test_all_vector():
    pass
    

def _lower__Z28nvshmem_size_test_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_size_test_all_vector_nbst(int &retval , unsigned long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long ** cmp_value) {
        retval = nvshmem_size_test_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z28nvshmem_size_test_all_vector_nbst = declare_device(
        '_Z28nvshmem_size_test_all_vector_nbst',
        int32(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z28nvshmem_size_test_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmem_size_test_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(size_test_all_vector, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z28nvshmem_size_test_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_size_test_all_vector_nbst_caller,
            signature(int32, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z28nvshmem_size_test_all_vector_nbst(shim_stream, shim_obj)


def ptrdiff_test_all_vector():
    pass
    

def _lower__Z31nvshmem_ptrdiff_test_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmem_ptrdiff_test_all_vector_nbst(int &retval , long ** ivars, unsigned long* nelems, int ** status, int* cmp, long ** cmp_value) {
        retval = nvshmem_ptrdiff_test_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z31nvshmem_ptrdiff_test_all_vector_nbst = declare_device(
        '_Z31nvshmem_ptrdiff_test_all_vector_nbst',
        int32(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z31nvshmem_ptrdiff_test_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmem_ptrdiff_test_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ptrdiff_test_all_vector, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z31nvshmem_ptrdiff_test_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmem_ptrdiff_test_all_vector_nbst_caller,
            signature(int32, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z31nvshmem_ptrdiff_test_all_vector_nbst(shim_stream, shim_obj)


def short_test_any_vector():
    pass
    

def _lower__Z29nvshmem_short_test_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_short_test_any_vector_nbst(unsigned long &retval , short ** ivars, unsigned long* nelems, int ** status, int* cmp, short ** cmp_value) {
        retval = nvshmem_short_test_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_short_test_any_vector_nbst = declare_device(
        '_Z29nvshmem_short_test_any_vector_nbst',
        uint64(
            CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int16))
        )
    )
    

    def _Z29nvshmem_short_test_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmem_short_test_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(short_test_any_vector, CPointer(int16), uint64, CPointer(int32), int32, CPointer(int16))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_short_test_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_short_test_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int16))),
            ptrs,
        )



_lower__Z29nvshmem_short_test_any_vector_nbst(shim_stream, shim_obj)


def int_test_any_vector():
    pass
    

def _lower__Z27nvshmem_int_test_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_int_test_any_vector_nbst(unsigned long &retval , int ** ivars, unsigned long* nelems, int ** status, int* cmp, int ** cmp_value) {
        retval = nvshmem_int_test_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z27nvshmem_int_test_any_vector_nbst = declare_device(
        '_Z27nvshmem_int_test_any_vector_nbst',
        uint64(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))
        )
    )
    

    def _Z27nvshmem_int_test_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmem_int_test_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int_test_any_vector, CPointer(int32), uint64, CPointer(int32), int32, CPointer(int32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z27nvshmem_int_test_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_int_test_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))),
            ptrs,
        )



_lower__Z27nvshmem_int_test_any_vector_nbst(shim_stream, shim_obj)


def long_test_any_vector():
    pass
    

def _lower__Z28nvshmem_long_test_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_long_test_any_vector_nbst(unsigned long &retval , long ** ivars, unsigned long* nelems, int ** status, int* cmp, long ** cmp_value) {
        retval = nvshmem_long_test_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z28nvshmem_long_test_any_vector_nbst = declare_device(
        '_Z28nvshmem_long_test_any_vector_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z28nvshmem_long_test_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmem_long_test_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(long_test_any_vector, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z28nvshmem_long_test_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_long_test_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z28nvshmem_long_test_any_vector_nbst(shim_stream, shim_obj)


def longlong_test_any_vector():
    pass
    

def _lower__Z32nvshmem_longlong_test_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmem_longlong_test_any_vector_nbst(unsigned long &retval , long long ** ivars, unsigned long* nelems, int ** status, int* cmp, long long ** cmp_value) {
        retval = nvshmem_longlong_test_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z32nvshmem_longlong_test_any_vector_nbst = declare_device(
        '_Z32nvshmem_longlong_test_any_vector_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z32nvshmem_longlong_test_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z32nvshmem_longlong_test_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(longlong_test_any_vector, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z32nvshmem_longlong_test_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmem_longlong_test_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z32nvshmem_longlong_test_any_vector_nbst(shim_stream, shim_obj)


def ushort_test_any_vector():
    pass
    

def _lower__Z30nvshmem_ushort_test_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_ushort_test_any_vector_nbst(unsigned long &retval , unsigned short ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned short ** cmp_value) {
        retval = nvshmem_ushort_test_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z30nvshmem_ushort_test_any_vector_nbst = declare_device(
        '_Z30nvshmem_ushort_test_any_vector_nbst',
        uint64(
            CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint16))
        )
    )
    

    def _Z30nvshmem_ushort_test_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmem_ushort_test_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ushort_test_any_vector, CPointer(uint16), uint64, CPointer(int32), int32, CPointer(uint16))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z30nvshmem_ushort_test_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_ushort_test_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint16))),
            ptrs,
        )



_lower__Z30nvshmem_ushort_test_any_vector_nbst(shim_stream, shim_obj)


def uint_test_any_vector():
    pass
    

def _lower__Z28nvshmem_uint_test_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_uint_test_any_vector_nbst(unsigned long &retval , unsigned int ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned int ** cmp_value) {
        retval = nvshmem_uint_test_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z28nvshmem_uint_test_any_vector_nbst = declare_device(
        '_Z28nvshmem_uint_test_any_vector_nbst',
        uint64(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))
        )
    )
    

    def _Z28nvshmem_uint_test_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmem_uint_test_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint_test_any_vector, CPointer(uint32), uint64, CPointer(int32), int32, CPointer(uint32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z28nvshmem_uint_test_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_uint_test_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))),
            ptrs,
        )



_lower__Z28nvshmem_uint_test_any_vector_nbst(shim_stream, shim_obj)


def ulong_test_any_vector():
    pass
    

def _lower__Z29nvshmem_ulong_test_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_ulong_test_any_vector_nbst(unsigned long &retval , unsigned long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long ** cmp_value) {
        retval = nvshmem_ulong_test_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_ulong_test_any_vector_nbst = declare_device(
        '_Z29nvshmem_ulong_test_any_vector_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z29nvshmem_ulong_test_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmem_ulong_test_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulong_test_any_vector, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_ulong_test_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_ulong_test_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z29nvshmem_ulong_test_any_vector_nbst(shim_stream, shim_obj)


def ulonglong_test_any_vector():
    pass
    

def _lower__Z33nvshmem_ulonglong_test_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmem_ulonglong_test_any_vector_nbst(unsigned long &retval , unsigned long long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long long ** cmp_value) {
        retval = nvshmem_ulonglong_test_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z33nvshmem_ulonglong_test_any_vector_nbst = declare_device(
        '_Z33nvshmem_ulonglong_test_any_vector_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z33nvshmem_ulonglong_test_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z33nvshmem_ulonglong_test_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulonglong_test_any_vector, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z33nvshmem_ulonglong_test_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmem_ulonglong_test_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z33nvshmem_ulonglong_test_any_vector_nbst(shim_stream, shim_obj)


def int32_test_any_vector():
    pass
    

def _lower__Z29nvshmem_int32_test_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_int32_test_any_vector_nbst(unsigned long &retval , int32_t ** ivars, unsigned long* nelems, int ** status, int* cmp, int32_t ** cmp_value) {
        retval = nvshmem_int32_test_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_int32_test_any_vector_nbst = declare_device(
        '_Z29nvshmem_int32_test_any_vector_nbst',
        uint64(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))
        )
    )
    

    def _Z29nvshmem_int32_test_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmem_int32_test_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int32_test_any_vector, CPointer(int32), uint64, CPointer(int32), int32, CPointer(int32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_int32_test_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_int32_test_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))),
            ptrs,
        )



_lower__Z29nvshmem_int32_test_any_vector_nbst(shim_stream, shim_obj)


def int64_test_any_vector():
    pass
    

def _lower__Z29nvshmem_int64_test_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_int64_test_any_vector_nbst(unsigned long &retval , int64_t ** ivars, unsigned long* nelems, int ** status, int* cmp, int64_t ** cmp_value) {
        retval = nvshmem_int64_test_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_int64_test_any_vector_nbst = declare_device(
        '_Z29nvshmem_int64_test_any_vector_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z29nvshmem_int64_test_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmem_int64_test_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int64_test_any_vector, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_int64_test_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_int64_test_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z29nvshmem_int64_test_any_vector_nbst(shim_stream, shim_obj)


def uint32_test_any_vector():
    pass
    

def _lower__Z30nvshmem_uint32_test_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_uint32_test_any_vector_nbst(unsigned long &retval , uint32_t ** ivars, unsigned long* nelems, int ** status, int* cmp, uint32_t ** cmp_value) {
        retval = nvshmem_uint32_test_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z30nvshmem_uint32_test_any_vector_nbst = declare_device(
        '_Z30nvshmem_uint32_test_any_vector_nbst',
        uint64(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))
        )
    )
    

    def _Z30nvshmem_uint32_test_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmem_uint32_test_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint32_test_any_vector, CPointer(uint32), uint64, CPointer(int32), int32, CPointer(uint32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z30nvshmem_uint32_test_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_uint32_test_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))),
            ptrs,
        )



_lower__Z30nvshmem_uint32_test_any_vector_nbst(shim_stream, shim_obj)


def uint64_test_any_vector():
    pass
    

def _lower__Z30nvshmem_uint64_test_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_uint64_test_any_vector_nbst(unsigned long &retval , uint64_t ** ivars, unsigned long* nelems, int ** status, int* cmp, uint64_t ** cmp_value) {
        retval = nvshmem_uint64_test_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z30nvshmem_uint64_test_any_vector_nbst = declare_device(
        '_Z30nvshmem_uint64_test_any_vector_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z30nvshmem_uint64_test_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmem_uint64_test_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint64_test_any_vector, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z30nvshmem_uint64_test_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_uint64_test_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z30nvshmem_uint64_test_any_vector_nbst(shim_stream, shim_obj)


def size_test_any_vector():
    pass
    

def _lower__Z28nvshmem_size_test_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_size_test_any_vector_nbst(unsigned long &retval , unsigned long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long ** cmp_value) {
        retval = nvshmem_size_test_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z28nvshmem_size_test_any_vector_nbst = declare_device(
        '_Z28nvshmem_size_test_any_vector_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z28nvshmem_size_test_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmem_size_test_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(size_test_any_vector, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z28nvshmem_size_test_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_size_test_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z28nvshmem_size_test_any_vector_nbst(shim_stream, shim_obj)


def ptrdiff_test_any_vector():
    pass
    

def _lower__Z31nvshmem_ptrdiff_test_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmem_ptrdiff_test_any_vector_nbst(unsigned long &retval , long ** ivars, unsigned long* nelems, int ** status, int* cmp, long ** cmp_value) {
        retval = nvshmem_ptrdiff_test_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z31nvshmem_ptrdiff_test_any_vector_nbst = declare_device(
        '_Z31nvshmem_ptrdiff_test_any_vector_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z31nvshmem_ptrdiff_test_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmem_ptrdiff_test_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ptrdiff_test_any_vector, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z31nvshmem_ptrdiff_test_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmem_ptrdiff_test_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z31nvshmem_ptrdiff_test_any_vector_nbst(shim_stream, shim_obj)


def short_test_some_vector():
    pass
    

def _lower__Z30nvshmem_short_test_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_short_test_some_vector_nbst(unsigned long &retval , short ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, short ** cmp_value) {
        retval = nvshmem_short_test_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z30nvshmem_short_test_some_vector_nbst = declare_device(
        '_Z30nvshmem_short_test_some_vector_nbst',
        uint64(
            CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int16))
        )
    )
    

    def _Z30nvshmem_short_test_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z30nvshmem_short_test_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(short_test_some_vector, CPointer(int16), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int16))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z30nvshmem_short_test_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_short_test_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int16))),
            ptrs,
        )



_lower__Z30nvshmem_short_test_some_vector_nbst(shim_stream, shim_obj)


def int_test_some_vector():
    pass
    

def _lower__Z28nvshmem_int_test_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_int_test_some_vector_nbst(unsigned long &retval , int ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, int ** cmp_value) {
        retval = nvshmem_int_test_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z28nvshmem_int_test_some_vector_nbst = declare_device(
        '_Z28nvshmem_int_test_some_vector_nbst',
        uint64(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))
        )
    )
    

    def _Z28nvshmem_int_test_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z28nvshmem_int_test_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int_test_some_vector, CPointer(int32), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z28nvshmem_int_test_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_int_test_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))),
            ptrs,
        )



_lower__Z28nvshmem_int_test_some_vector_nbst(shim_stream, shim_obj)


def long_test_some_vector():
    pass
    

def _lower__Z29nvshmem_long_test_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_long_test_some_vector_nbst(unsigned long &retval , long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, long ** cmp_value) {
        retval = nvshmem_long_test_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_long_test_some_vector_nbst = declare_device(
        '_Z29nvshmem_long_test_some_vector_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z29nvshmem_long_test_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z29nvshmem_long_test_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(long_test_some_vector, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_long_test_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_long_test_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z29nvshmem_long_test_some_vector_nbst(shim_stream, shim_obj)


def longlong_test_some_vector():
    pass
    

def _lower__Z33nvshmem_longlong_test_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmem_longlong_test_some_vector_nbst(unsigned long &retval , long long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, long long ** cmp_value) {
        retval = nvshmem_longlong_test_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z33nvshmem_longlong_test_some_vector_nbst = declare_device(
        '_Z33nvshmem_longlong_test_some_vector_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z33nvshmem_longlong_test_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z33nvshmem_longlong_test_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(longlong_test_some_vector, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z33nvshmem_longlong_test_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmem_longlong_test_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z33nvshmem_longlong_test_some_vector_nbst(shim_stream, shim_obj)


def ushort_test_some_vector():
    pass
    

def _lower__Z31nvshmem_ushort_test_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmem_ushort_test_some_vector_nbst(unsigned long &retval , unsigned short ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned short ** cmp_value) {
        retval = nvshmem_ushort_test_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z31nvshmem_ushort_test_some_vector_nbst = declare_device(
        '_Z31nvshmem_ushort_test_some_vector_nbst',
        uint64(
            CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint16))
        )
    )
    

    def _Z31nvshmem_ushort_test_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z31nvshmem_ushort_test_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ushort_test_some_vector, CPointer(uint16), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint16))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z31nvshmem_ushort_test_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmem_ushort_test_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint16))),
            ptrs,
        )



_lower__Z31nvshmem_ushort_test_some_vector_nbst(shim_stream, shim_obj)


def uint_test_some_vector():
    pass
    

def _lower__Z29nvshmem_uint_test_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_uint_test_some_vector_nbst(unsigned long &retval , unsigned int ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned int ** cmp_value) {
        retval = nvshmem_uint_test_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_uint_test_some_vector_nbst = declare_device(
        '_Z29nvshmem_uint_test_some_vector_nbst',
        uint64(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))
        )
    )
    

    def _Z29nvshmem_uint_test_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z29nvshmem_uint_test_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint_test_some_vector, CPointer(uint32), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_uint_test_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_uint_test_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))),
            ptrs,
        )



_lower__Z29nvshmem_uint_test_some_vector_nbst(shim_stream, shim_obj)


def ulong_test_some_vector():
    pass
    

def _lower__Z30nvshmem_ulong_test_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_ulong_test_some_vector_nbst(unsigned long &retval , unsigned long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned long ** cmp_value) {
        retval = nvshmem_ulong_test_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z30nvshmem_ulong_test_some_vector_nbst = declare_device(
        '_Z30nvshmem_ulong_test_some_vector_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z30nvshmem_ulong_test_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z30nvshmem_ulong_test_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulong_test_some_vector, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z30nvshmem_ulong_test_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_ulong_test_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z30nvshmem_ulong_test_some_vector_nbst(shim_stream, shim_obj)


def ulonglong_test_some_vector():
    pass
    

def _lower__Z34nvshmem_ulonglong_test_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmem_ulonglong_test_some_vector_nbst(unsigned long &retval , unsigned long long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned long long ** cmp_value) {
        retval = nvshmem_ulonglong_test_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z34nvshmem_ulonglong_test_some_vector_nbst = declare_device(
        '_Z34nvshmem_ulonglong_test_some_vector_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z34nvshmem_ulonglong_test_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z34nvshmem_ulonglong_test_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulonglong_test_some_vector, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z34nvshmem_ulonglong_test_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmem_ulonglong_test_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z34nvshmem_ulonglong_test_some_vector_nbst(shim_stream, shim_obj)


def int32_test_some_vector():
    pass
    

def _lower__Z30nvshmem_int32_test_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_int32_test_some_vector_nbst(unsigned long &retval , int32_t ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, int32_t ** cmp_value) {
        retval = nvshmem_int32_test_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z30nvshmem_int32_test_some_vector_nbst = declare_device(
        '_Z30nvshmem_int32_test_some_vector_nbst',
        uint64(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))
        )
    )
    

    def _Z30nvshmem_int32_test_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z30nvshmem_int32_test_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int32_test_some_vector, CPointer(int32), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z30nvshmem_int32_test_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_int32_test_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))),
            ptrs,
        )



_lower__Z30nvshmem_int32_test_some_vector_nbst(shim_stream, shim_obj)


def int64_test_some_vector():
    pass
    

def _lower__Z30nvshmem_int64_test_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_int64_test_some_vector_nbst(unsigned long &retval , int64_t ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, int64_t ** cmp_value) {
        retval = nvshmem_int64_test_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z30nvshmem_int64_test_some_vector_nbst = declare_device(
        '_Z30nvshmem_int64_test_some_vector_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z30nvshmem_int64_test_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z30nvshmem_int64_test_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int64_test_some_vector, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z30nvshmem_int64_test_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_int64_test_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z30nvshmem_int64_test_some_vector_nbst(shim_stream, shim_obj)


def uint32_test_some_vector():
    pass
    

def _lower__Z31nvshmem_uint32_test_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmem_uint32_test_some_vector_nbst(unsigned long &retval , uint32_t ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, uint32_t ** cmp_value) {
        retval = nvshmem_uint32_test_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z31nvshmem_uint32_test_some_vector_nbst = declare_device(
        '_Z31nvshmem_uint32_test_some_vector_nbst',
        uint64(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))
        )
    )
    

    def _Z31nvshmem_uint32_test_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z31nvshmem_uint32_test_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint32_test_some_vector, CPointer(uint32), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z31nvshmem_uint32_test_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmem_uint32_test_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))),
            ptrs,
        )



_lower__Z31nvshmem_uint32_test_some_vector_nbst(shim_stream, shim_obj)


def uint64_test_some_vector():
    pass
    

def _lower__Z31nvshmem_uint64_test_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmem_uint64_test_some_vector_nbst(unsigned long &retval , uint64_t ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, uint64_t ** cmp_value) {
        retval = nvshmem_uint64_test_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z31nvshmem_uint64_test_some_vector_nbst = declare_device(
        '_Z31nvshmem_uint64_test_some_vector_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z31nvshmem_uint64_test_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z31nvshmem_uint64_test_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint64_test_some_vector, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z31nvshmem_uint64_test_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmem_uint64_test_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z31nvshmem_uint64_test_some_vector_nbst(shim_stream, shim_obj)


def size_test_some_vector():
    pass
    

def _lower__Z29nvshmem_size_test_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_size_test_some_vector_nbst(unsigned long &retval , unsigned long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned long ** cmp_value) {
        retval = nvshmem_size_test_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_size_test_some_vector_nbst = declare_device(
        '_Z29nvshmem_size_test_some_vector_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z29nvshmem_size_test_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z29nvshmem_size_test_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(size_test_some_vector, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_size_test_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_size_test_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z29nvshmem_size_test_some_vector_nbst(shim_stream, shim_obj)


def ptrdiff_test_some_vector():
    pass
    

def _lower__Z32nvshmem_ptrdiff_test_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmem_ptrdiff_test_some_vector_nbst(unsigned long &retval , long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, long ** cmp_value) {
        retval = nvshmem_ptrdiff_test_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z32nvshmem_ptrdiff_test_some_vector_nbst = declare_device(
        '_Z32nvshmem_ptrdiff_test_some_vector_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z32nvshmem_ptrdiff_test_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z32nvshmem_ptrdiff_test_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ptrdiff_test_some_vector, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z32nvshmem_ptrdiff_test_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmem_ptrdiff_test_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z32nvshmem_ptrdiff_test_some_vector_nbst(shim_stream, shim_obj)


def short_wait_until():
    pass
    

def _lower__Z24nvshmem_short_wait_until_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_short_wait_until_nbst(int &retval , short ** ivar, int* cmp, short* cmp_value) {
        nvshmem_short_wait_until(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z24nvshmem_short_wait_until_nbst = declare_device(
        '_Z24nvshmem_short_wait_until_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(int32), CPointer(int16)
        )
    )
    

    def _Z24nvshmem_short_wait_until_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_short_wait_until_nbst(arg_0, arg_1, arg_2)
    

    @lower(short_wait_until, CPointer(int16), int32, int16)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z24nvshmem_short_wait_until_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_short_wait_until_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(int32), CPointer(int16)),
            ptrs,
        )



_lower__Z24nvshmem_short_wait_until_nbst(shim_stream, shim_obj)


def int_wait_until():
    pass
    

def _lower__Z22nvshmem_int_wait_until_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_int_wait_until_nbst(int &retval , int ** ivar, int* cmp, int* cmp_value) {
        nvshmem_int_wait_until(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z22nvshmem_int_wait_until_nbst = declare_device(
        '_Z22nvshmem_int_wait_until_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_int_wait_until_nbst_caller(arg_0, arg_1, arg_2):
        return _Z22nvshmem_int_wait_until_nbst(arg_0, arg_1, arg_2)
    

    @lower(int_wait_until, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z22nvshmem_int_wait_until_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_int_wait_until_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_int_wait_until_nbst(shim_stream, shim_obj)


def long_wait_until():
    pass
    

def _lower__Z23nvshmem_long_wait_until_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_long_wait_until_nbst(int &retval , long ** ivar, int* cmp, long* cmp_value) {
        nvshmem_long_wait_until(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z23nvshmem_long_wait_until_nbst = declare_device(
        '_Z23nvshmem_long_wait_until_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z23nvshmem_long_wait_until_nbst_caller(arg_0, arg_1, arg_2):
        return _Z23nvshmem_long_wait_until_nbst(arg_0, arg_1, arg_2)
    

    @lower(long_wait_until, CPointer(int64), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z23nvshmem_long_wait_until_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_long_wait_until_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z23nvshmem_long_wait_until_nbst(shim_stream, shim_obj)


def longlong_wait_until():
    pass
    

def _lower__Z27nvshmem_longlong_wait_until_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_longlong_wait_until_nbst(int &retval , long long ** ivar, int* cmp, long long* cmp_value) {
        nvshmem_longlong_wait_until(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z27nvshmem_longlong_wait_until_nbst = declare_device(
        '_Z27nvshmem_longlong_wait_until_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z27nvshmem_longlong_wait_until_nbst_caller(arg_0, arg_1, arg_2):
        return _Z27nvshmem_longlong_wait_until_nbst(arg_0, arg_1, arg_2)
    

    @lower(longlong_wait_until, CPointer(int64), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z27nvshmem_longlong_wait_until_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_longlong_wait_until_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z27nvshmem_longlong_wait_until_nbst(shim_stream, shim_obj)


def ushort_wait_until():
    pass
    

def _lower__Z25nvshmem_ushort_wait_until_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_ushort_wait_until_nbst(int &retval , unsigned short ** ivar, int* cmp, unsigned short* cmp_value) {
        nvshmem_ushort_wait_until(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z25nvshmem_ushort_wait_until_nbst = declare_device(
        '_Z25nvshmem_ushort_wait_until_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(int32), CPointer(uint16)
        )
    )
    

    def _Z25nvshmem_ushort_wait_until_nbst_caller(arg_0, arg_1, arg_2):
        return _Z25nvshmem_ushort_wait_until_nbst(arg_0, arg_1, arg_2)
    

    @lower(ushort_wait_until, CPointer(uint16), int32, uint16)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z25nvshmem_ushort_wait_until_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_ushort_wait_until_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(int32), CPointer(uint16)),
            ptrs,
        )



_lower__Z25nvshmem_ushort_wait_until_nbst(shim_stream, shim_obj)


def uint_wait_until():
    pass
    

def _lower__Z23nvshmem_uint_wait_until_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_uint_wait_until_nbst(int &retval , unsigned int ** ivar, int* cmp, unsigned int* cmp_value) {
        nvshmem_uint_wait_until(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z23nvshmem_uint_wait_until_nbst = declare_device(
        '_Z23nvshmem_uint_wait_until_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(int32), CPointer(uint32)
        )
    )
    

    def _Z23nvshmem_uint_wait_until_nbst_caller(arg_0, arg_1, arg_2):
        return _Z23nvshmem_uint_wait_until_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint_wait_until, CPointer(uint32), int32, uint32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z23nvshmem_uint_wait_until_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_uint_wait_until_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(int32), CPointer(uint32)),
            ptrs,
        )



_lower__Z23nvshmem_uint_wait_until_nbst(shim_stream, shim_obj)


def ulong_wait_until():
    pass
    

def _lower__Z24nvshmem_ulong_wait_until_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_ulong_wait_until_nbst(int &retval , unsigned long ** ivar, int* cmp, unsigned long* cmp_value) {
        nvshmem_ulong_wait_until(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z24nvshmem_ulong_wait_until_nbst = declare_device(
        '_Z24nvshmem_ulong_wait_until_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z24nvshmem_ulong_wait_until_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_ulong_wait_until_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulong_wait_until, CPointer(uint64), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z24nvshmem_ulong_wait_until_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_ulong_wait_until_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z24nvshmem_ulong_wait_until_nbst(shim_stream, shim_obj)


def ulonglong_wait_until():
    pass
    

def _lower__Z28nvshmem_ulonglong_wait_until_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_ulonglong_wait_until_nbst(int &retval , unsigned long long ** ivar, int* cmp, unsigned long long* cmp_value) {
        nvshmem_ulonglong_wait_until(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z28nvshmem_ulonglong_wait_until_nbst = declare_device(
        '_Z28nvshmem_ulonglong_wait_until_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z28nvshmem_ulonglong_wait_until_nbst_caller(arg_0, arg_1, arg_2):
        return _Z28nvshmem_ulonglong_wait_until_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulonglong_wait_until, CPointer(uint64), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z28nvshmem_ulonglong_wait_until_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_ulonglong_wait_until_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z28nvshmem_ulonglong_wait_until_nbst(shim_stream, shim_obj)


def int32_wait_until():
    pass
    

def _lower__Z24nvshmem_int32_wait_until_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_int32_wait_until_nbst(int &retval , int32_t ** ivar, int* cmp, int32_t* cmp_value) {
        nvshmem_int32_wait_until(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z24nvshmem_int32_wait_until_nbst = declare_device(
        '_Z24nvshmem_int32_wait_until_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_int32_wait_until_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_int32_wait_until_nbst(arg_0, arg_1, arg_2)
    

    @lower(int32_wait_until, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z24nvshmem_int32_wait_until_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_int32_wait_until_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_int32_wait_until_nbst(shim_stream, shim_obj)


def int64_wait_until():
    pass
    

def _lower__Z24nvshmem_int64_wait_until_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_int64_wait_until_nbst(int &retval , int64_t ** ivar, int* cmp, int64_t* cmp_value) {
        nvshmem_int64_wait_until(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z24nvshmem_int64_wait_until_nbst = declare_device(
        '_Z24nvshmem_int64_wait_until_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z24nvshmem_int64_wait_until_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_int64_wait_until_nbst(arg_0, arg_1, arg_2)
    

    @lower(int64_wait_until, CPointer(int64), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z24nvshmem_int64_wait_until_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_int64_wait_until_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z24nvshmem_int64_wait_until_nbst(shim_stream, shim_obj)


def uint32_wait_until():
    pass
    

def _lower__Z25nvshmem_uint32_wait_until_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_uint32_wait_until_nbst(int &retval , uint32_t ** ivar, int* cmp, uint32_t* cmp_value) {
        nvshmem_uint32_wait_until(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z25nvshmem_uint32_wait_until_nbst = declare_device(
        '_Z25nvshmem_uint32_wait_until_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(int32), CPointer(uint32)
        )
    )
    

    def _Z25nvshmem_uint32_wait_until_nbst_caller(arg_0, arg_1, arg_2):
        return _Z25nvshmem_uint32_wait_until_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint32_wait_until, CPointer(uint32), int32, uint32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z25nvshmem_uint32_wait_until_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_uint32_wait_until_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(int32), CPointer(uint32)),
            ptrs,
        )



_lower__Z25nvshmem_uint32_wait_until_nbst(shim_stream, shim_obj)


def uint64_wait_until():
    pass
    

def _lower__Z25nvshmem_uint64_wait_until_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_uint64_wait_until_nbst(int &retval , uint64_t ** ivar, int* cmp, uint64_t* cmp_value) {
        nvshmem_uint64_wait_until(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z25nvshmem_uint64_wait_until_nbst = declare_device(
        '_Z25nvshmem_uint64_wait_until_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z25nvshmem_uint64_wait_until_nbst_caller(arg_0, arg_1, arg_2):
        return _Z25nvshmem_uint64_wait_until_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint64_wait_until, CPointer(uint64), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z25nvshmem_uint64_wait_until_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_uint64_wait_until_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z25nvshmem_uint64_wait_until_nbst(shim_stream, shim_obj)


def size_wait_until():
    pass
    

def _lower__Z23nvshmem_size_wait_until_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_size_wait_until_nbst(int &retval , unsigned long ** ivar, int* cmp, unsigned long* cmp_value) {
        nvshmem_size_wait_until(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z23nvshmem_size_wait_until_nbst = declare_device(
        '_Z23nvshmem_size_wait_until_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z23nvshmem_size_wait_until_nbst_caller(arg_0, arg_1, arg_2):
        return _Z23nvshmem_size_wait_until_nbst(arg_0, arg_1, arg_2)
    

    @lower(size_wait_until, CPointer(uint64), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z23nvshmem_size_wait_until_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_size_wait_until_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z23nvshmem_size_wait_until_nbst(shim_stream, shim_obj)


def ptrdiff_wait_until():
    pass
    

def _lower__Z26nvshmem_ptrdiff_wait_until_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmem_ptrdiff_wait_until_nbst(int &retval , long ** ivar, int* cmp, long* cmp_value) {
        nvshmem_ptrdiff_wait_until(*ivar, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z26nvshmem_ptrdiff_wait_until_nbst = declare_device(
        '_Z26nvshmem_ptrdiff_wait_until_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z26nvshmem_ptrdiff_wait_until_nbst_caller(arg_0, arg_1, arg_2):
        return _Z26nvshmem_ptrdiff_wait_until_nbst(arg_0, arg_1, arg_2)
    

    @lower(ptrdiff_wait_until, CPointer(int64), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z26nvshmem_ptrdiff_wait_until_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmem_ptrdiff_wait_until_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z26nvshmem_ptrdiff_wait_until_nbst(shim_stream, shim_obj)


def signal_fetch():
    pass
    

def _lower__Z20nvshmem_signal_fetch_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmem_signal_fetch_nbst(uint64_t &retval , uint64_t ** sig_addr) {
        retval = nvshmem_signal_fetch(*sig_addr);
        return 0;
    }
        """


    _Z20nvshmem_signal_fetch_nbst = declare_device(
        '_Z20nvshmem_signal_fetch_nbst',
        uint64(
            CPointer(CPointer(uint64))
        )
    )
    

    def _Z20nvshmem_signal_fetch_nbst_caller(arg_0):
        return _Z20nvshmem_signal_fetch_nbst(arg_0)
    

    @lower(signal_fetch, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmem_signal_fetch_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmem_signal_fetch_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z20nvshmem_signal_fetch_nbst(shim_stream, shim_obj)


def signal_wait_until():
    pass
    

def _lower__Z25nvshmem_signal_wait_until_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_signal_wait_until_nbst(uint64_t &retval , uint64_t ** sig_addr, int* cmp, uint64_t* cmp_val) {
        retval = nvshmem_signal_wait_until(*sig_addr, *cmp, *cmp_val);
        return 0;
    }
        """


    _Z25nvshmem_signal_wait_until_nbst = declare_device(
        '_Z25nvshmem_signal_wait_until_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z25nvshmem_signal_wait_until_nbst_caller(arg_0, arg_1, arg_2):
        return _Z25nvshmem_signal_wait_until_nbst(arg_0, arg_1, arg_2)
    

    @lower(signal_wait_until, CPointer(uint64), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z25nvshmem_signal_wait_until_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_signal_wait_until_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z25nvshmem_signal_wait_until_nbst(shim_stream, shim_obj)


def short_wait_until_all():
    pass
    

def _lower__Z28nvshmem_short_wait_until_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_short_wait_until_all_nbst(int &retval , short ** ivars, unsigned long* nelems, int ** status, int* cmp, short* cmp_value) {
        nvshmem_short_wait_until_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z28nvshmem_short_wait_until_all_nbst = declare_device(
        '_Z28nvshmem_short_wait_until_all_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int16)
        )
    )
    

    def _Z28nvshmem_short_wait_until_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmem_short_wait_until_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(short_wait_until_all, CPointer(int16), uint64, CPointer(int32), int32, int16)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z28nvshmem_short_wait_until_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_short_wait_until_all_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int16)),
            ptrs,
        )



_lower__Z28nvshmem_short_wait_until_all_nbst(shim_stream, shim_obj)


def int_wait_until_all():
    pass
    

def _lower__Z26nvshmem_int_wait_until_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmem_int_wait_until_all_nbst(int &retval , int ** ivars, unsigned long* nelems, int ** status, int* cmp, int* cmp_value) {
        nvshmem_int_wait_until_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z26nvshmem_int_wait_until_all_nbst = declare_device(
        '_Z26nvshmem_int_wait_until_all_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmem_int_wait_until_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmem_int_wait_until_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int_wait_until_all, CPointer(int32), uint64, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z26nvshmem_int_wait_until_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmem_int_wait_until_all_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmem_int_wait_until_all_nbst(shim_stream, shim_obj)


def long_wait_until_all():
    pass
    

def _lower__Z27nvshmem_long_wait_until_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_long_wait_until_all_nbst(int &retval , long ** ivars, unsigned long* nelems, int ** status, int* cmp, long* cmp_value) {
        nvshmem_long_wait_until_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z27nvshmem_long_wait_until_all_nbst = declare_device(
        '_Z27nvshmem_long_wait_until_all_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z27nvshmem_long_wait_until_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmem_long_wait_until_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(long_wait_until_all, CPointer(int64), uint64, CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z27nvshmem_long_wait_until_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_long_wait_until_all_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z27nvshmem_long_wait_until_all_nbst(shim_stream, shim_obj)


def longlong_wait_until_all():
    pass
    

def _lower__Z31nvshmem_longlong_wait_until_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmem_longlong_wait_until_all_nbst(int &retval , long long ** ivars, unsigned long* nelems, int ** status, int* cmp, long long* cmp_value) {
        nvshmem_longlong_wait_until_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z31nvshmem_longlong_wait_until_all_nbst = declare_device(
        '_Z31nvshmem_longlong_wait_until_all_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z31nvshmem_longlong_wait_until_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmem_longlong_wait_until_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(longlong_wait_until_all, CPointer(int64), uint64, CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z31nvshmem_longlong_wait_until_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmem_longlong_wait_until_all_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z31nvshmem_longlong_wait_until_all_nbst(shim_stream, shim_obj)


def ushort_wait_until_all():
    pass
    

def _lower__Z29nvshmem_ushort_wait_until_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_ushort_wait_until_all_nbst(int &retval , unsigned short ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned short* cmp_value) {
        nvshmem_ushort_wait_until_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_ushort_wait_until_all_nbst = declare_device(
        '_Z29nvshmem_ushort_wait_until_all_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint16)
        )
    )
    

    def _Z29nvshmem_ushort_wait_until_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmem_ushort_wait_until_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ushort_wait_until_all, CPointer(uint16), uint64, CPointer(int32), int32, uint16)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_ushort_wait_until_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_ushort_wait_until_all_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint16)),
            ptrs,
        )



_lower__Z29nvshmem_ushort_wait_until_all_nbst(shim_stream, shim_obj)


def uint_wait_until_all():
    pass
    

def _lower__Z27nvshmem_uint_wait_until_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_uint_wait_until_all_nbst(int &retval , unsigned int ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned int* cmp_value) {
        nvshmem_uint_wait_until_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z27nvshmem_uint_wait_until_all_nbst = declare_device(
        '_Z27nvshmem_uint_wait_until_all_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)
        )
    )
    

    def _Z27nvshmem_uint_wait_until_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmem_uint_wait_until_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint_wait_until_all, CPointer(uint32), uint64, CPointer(int32), int32, uint32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z27nvshmem_uint_wait_until_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_uint_wait_until_all_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)),
            ptrs,
        )



_lower__Z27nvshmem_uint_wait_until_all_nbst(shim_stream, shim_obj)


def ulong_wait_until_all():
    pass
    

def _lower__Z28nvshmem_ulong_wait_until_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_ulong_wait_until_all_nbst(int &retval , unsigned long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long* cmp_value) {
        nvshmem_ulong_wait_until_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z28nvshmem_ulong_wait_until_all_nbst = declare_device(
        '_Z28nvshmem_ulong_wait_until_all_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z28nvshmem_ulong_wait_until_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmem_ulong_wait_until_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulong_wait_until_all, CPointer(uint64), uint64, CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z28nvshmem_ulong_wait_until_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_ulong_wait_until_all_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z28nvshmem_ulong_wait_until_all_nbst(shim_stream, shim_obj)


def ulonglong_wait_until_all():
    pass
    

def _lower__Z32nvshmem_ulonglong_wait_until_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmem_ulonglong_wait_until_all_nbst(int &retval , unsigned long long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long long* cmp_value) {
        nvshmem_ulonglong_wait_until_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z32nvshmem_ulonglong_wait_until_all_nbst = declare_device(
        '_Z32nvshmem_ulonglong_wait_until_all_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z32nvshmem_ulonglong_wait_until_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z32nvshmem_ulonglong_wait_until_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulonglong_wait_until_all, CPointer(uint64), uint64, CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z32nvshmem_ulonglong_wait_until_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmem_ulonglong_wait_until_all_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z32nvshmem_ulonglong_wait_until_all_nbst(shim_stream, shim_obj)


def int32_wait_until_all():
    pass
    

def _lower__Z28nvshmem_int32_wait_until_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_int32_wait_until_all_nbst(int &retval , int32_t ** ivars, unsigned long* nelems, int ** status, int* cmp, int32_t* cmp_value) {
        nvshmem_int32_wait_until_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z28nvshmem_int32_wait_until_all_nbst = declare_device(
        '_Z28nvshmem_int32_wait_until_all_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_int32_wait_until_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmem_int32_wait_until_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int32_wait_until_all, CPointer(int32), uint64, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z28nvshmem_int32_wait_until_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_int32_wait_until_all_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_int32_wait_until_all_nbst(shim_stream, shim_obj)


def int64_wait_until_all():
    pass
    

def _lower__Z28nvshmem_int64_wait_until_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_int64_wait_until_all_nbst(int &retval , int64_t ** ivars, unsigned long* nelems, int ** status, int* cmp, int64_t* cmp_value) {
        nvshmem_int64_wait_until_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z28nvshmem_int64_wait_until_all_nbst = declare_device(
        '_Z28nvshmem_int64_wait_until_all_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z28nvshmem_int64_wait_until_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmem_int64_wait_until_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int64_wait_until_all, CPointer(int64), uint64, CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z28nvshmem_int64_wait_until_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_int64_wait_until_all_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z28nvshmem_int64_wait_until_all_nbst(shim_stream, shim_obj)


def uint32_wait_until_all():
    pass
    

def _lower__Z29nvshmem_uint32_wait_until_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_uint32_wait_until_all_nbst(int &retval , uint32_t ** ivars, unsigned long* nelems, int ** status, int* cmp, uint32_t* cmp_value) {
        nvshmem_uint32_wait_until_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_uint32_wait_until_all_nbst = declare_device(
        '_Z29nvshmem_uint32_wait_until_all_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)
        )
    )
    

    def _Z29nvshmem_uint32_wait_until_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmem_uint32_wait_until_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint32_wait_until_all, CPointer(uint32), uint64, CPointer(int32), int32, uint32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_uint32_wait_until_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_uint32_wait_until_all_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)),
            ptrs,
        )



_lower__Z29nvshmem_uint32_wait_until_all_nbst(shim_stream, shim_obj)


def uint64_wait_until_all():
    pass
    

def _lower__Z29nvshmem_uint64_wait_until_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_uint64_wait_until_all_nbst(int &retval , uint64_t ** ivars, unsigned long* nelems, int ** status, int* cmp, uint64_t* cmp_value) {
        nvshmem_uint64_wait_until_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_uint64_wait_until_all_nbst = declare_device(
        '_Z29nvshmem_uint64_wait_until_all_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z29nvshmem_uint64_wait_until_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmem_uint64_wait_until_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint64_wait_until_all, CPointer(uint64), uint64, CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_uint64_wait_until_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_uint64_wait_until_all_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z29nvshmem_uint64_wait_until_all_nbst(shim_stream, shim_obj)


def size_wait_until_all():
    pass
    

def _lower__Z27nvshmem_size_wait_until_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_size_wait_until_all_nbst(int &retval , unsigned long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long* cmp_value) {
        nvshmem_size_wait_until_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z27nvshmem_size_wait_until_all_nbst = declare_device(
        '_Z27nvshmem_size_wait_until_all_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z27nvshmem_size_wait_until_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmem_size_wait_until_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(size_wait_until_all, CPointer(uint64), uint64, CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z27nvshmem_size_wait_until_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_size_wait_until_all_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z27nvshmem_size_wait_until_all_nbst(shim_stream, shim_obj)


def ptrdiff_wait_until_all():
    pass
    

def _lower__Z30nvshmem_ptrdiff_wait_until_all_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_ptrdiff_wait_until_all_nbst(int &retval , long ** ivars, unsigned long* nelems, int ** status, int* cmp, long* cmp_value) {
        nvshmem_ptrdiff_wait_until_all(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z30nvshmem_ptrdiff_wait_until_all_nbst = declare_device(
        '_Z30nvshmem_ptrdiff_wait_until_all_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z30nvshmem_ptrdiff_wait_until_all_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmem_ptrdiff_wait_until_all_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ptrdiff_wait_until_all, CPointer(int64), uint64, CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z30nvshmem_ptrdiff_wait_until_all_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_ptrdiff_wait_until_all_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z30nvshmem_ptrdiff_wait_until_all_nbst(shim_stream, shim_obj)


def short_wait_until_any():
    pass
    

def _lower__Z28nvshmem_short_wait_until_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_short_wait_until_any_nbst(unsigned long &retval , short ** ivars, unsigned long* nelems, int ** status, int* cmp, short* cmp_value) {
        retval = nvshmem_short_wait_until_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z28nvshmem_short_wait_until_any_nbst = declare_device(
        '_Z28nvshmem_short_wait_until_any_nbst',
        uint64(
            CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int16)
        )
    )
    

    def _Z28nvshmem_short_wait_until_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmem_short_wait_until_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(short_wait_until_any, CPointer(int16), uint64, CPointer(int32), int32, int16)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z28nvshmem_short_wait_until_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_short_wait_until_any_nbst_caller,
            signature(uint64, CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int16)),
            ptrs,
        )



_lower__Z28nvshmem_short_wait_until_any_nbst(shim_stream, shim_obj)


def int_wait_until_any():
    pass
    

def _lower__Z26nvshmem_int_wait_until_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmem_int_wait_until_any_nbst(unsigned long &retval , int ** ivars, unsigned long* nelems, int ** status, int* cmp, int* cmp_value) {
        retval = nvshmem_int_wait_until_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z26nvshmem_int_wait_until_any_nbst = declare_device(
        '_Z26nvshmem_int_wait_until_any_nbst',
        uint64(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmem_int_wait_until_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmem_int_wait_until_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int_wait_until_any, CPointer(int32), uint64, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z26nvshmem_int_wait_until_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmem_int_wait_until_any_nbst_caller,
            signature(uint64, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmem_int_wait_until_any_nbst(shim_stream, shim_obj)


def long_wait_until_any():
    pass
    

def _lower__Z27nvshmem_long_wait_until_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_long_wait_until_any_nbst(unsigned long &retval , long ** ivars, unsigned long* nelems, int ** status, int* cmp, long* cmp_value) {
        retval = nvshmem_long_wait_until_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z27nvshmem_long_wait_until_any_nbst = declare_device(
        '_Z27nvshmem_long_wait_until_any_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z27nvshmem_long_wait_until_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmem_long_wait_until_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(long_wait_until_any, CPointer(int64), uint64, CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z27nvshmem_long_wait_until_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_long_wait_until_any_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z27nvshmem_long_wait_until_any_nbst(shim_stream, shim_obj)


def longlong_wait_until_any():
    pass
    

def _lower__Z31nvshmem_longlong_wait_until_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmem_longlong_wait_until_any_nbst(unsigned long &retval , long long ** ivars, unsigned long* nelems, int ** status, int* cmp, long long* cmp_value) {
        retval = nvshmem_longlong_wait_until_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z31nvshmem_longlong_wait_until_any_nbst = declare_device(
        '_Z31nvshmem_longlong_wait_until_any_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z31nvshmem_longlong_wait_until_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmem_longlong_wait_until_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(longlong_wait_until_any, CPointer(int64), uint64, CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z31nvshmem_longlong_wait_until_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmem_longlong_wait_until_any_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z31nvshmem_longlong_wait_until_any_nbst(shim_stream, shim_obj)


def ushort_wait_until_any():
    pass
    

def _lower__Z29nvshmem_ushort_wait_until_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_ushort_wait_until_any_nbst(unsigned long &retval , unsigned short ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned short* cmp_value) {
        retval = nvshmem_ushort_wait_until_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_ushort_wait_until_any_nbst = declare_device(
        '_Z29nvshmem_ushort_wait_until_any_nbst',
        uint64(
            CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint16)
        )
    )
    

    def _Z29nvshmem_ushort_wait_until_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmem_ushort_wait_until_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ushort_wait_until_any, CPointer(uint16), uint64, CPointer(int32), int32, uint16)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_ushort_wait_until_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_ushort_wait_until_any_nbst_caller,
            signature(uint64, CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint16)),
            ptrs,
        )



_lower__Z29nvshmem_ushort_wait_until_any_nbst(shim_stream, shim_obj)


def uint_wait_until_any():
    pass
    

def _lower__Z27nvshmem_uint_wait_until_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_uint_wait_until_any_nbst(unsigned long &retval , unsigned int ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned int* cmp_value) {
        retval = nvshmem_uint_wait_until_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z27nvshmem_uint_wait_until_any_nbst = declare_device(
        '_Z27nvshmem_uint_wait_until_any_nbst',
        uint64(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)
        )
    )
    

    def _Z27nvshmem_uint_wait_until_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmem_uint_wait_until_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint_wait_until_any, CPointer(uint32), uint64, CPointer(int32), int32, uint32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z27nvshmem_uint_wait_until_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_uint_wait_until_any_nbst_caller,
            signature(uint64, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)),
            ptrs,
        )



_lower__Z27nvshmem_uint_wait_until_any_nbst(shim_stream, shim_obj)


def ulong_wait_until_any():
    pass
    

def _lower__Z28nvshmem_ulong_wait_until_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_ulong_wait_until_any_nbst(unsigned long &retval , unsigned long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long* cmp_value) {
        retval = nvshmem_ulong_wait_until_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z28nvshmem_ulong_wait_until_any_nbst = declare_device(
        '_Z28nvshmem_ulong_wait_until_any_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z28nvshmem_ulong_wait_until_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmem_ulong_wait_until_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulong_wait_until_any, CPointer(uint64), uint64, CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z28nvshmem_ulong_wait_until_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_ulong_wait_until_any_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z28nvshmem_ulong_wait_until_any_nbst(shim_stream, shim_obj)


def ulonglong_wait_until_any():
    pass
    

def _lower__Z32nvshmem_ulonglong_wait_until_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmem_ulonglong_wait_until_any_nbst(unsigned long &retval , unsigned long long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long long* cmp_value) {
        retval = nvshmem_ulonglong_wait_until_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z32nvshmem_ulonglong_wait_until_any_nbst = declare_device(
        '_Z32nvshmem_ulonglong_wait_until_any_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z32nvshmem_ulonglong_wait_until_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z32nvshmem_ulonglong_wait_until_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulonglong_wait_until_any, CPointer(uint64), uint64, CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z32nvshmem_ulonglong_wait_until_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmem_ulonglong_wait_until_any_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z32nvshmem_ulonglong_wait_until_any_nbst(shim_stream, shim_obj)


def int32_wait_until_any():
    pass
    

def _lower__Z28nvshmem_int32_wait_until_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_int32_wait_until_any_nbst(unsigned long &retval , int32_t ** ivars, unsigned long* nelems, int ** status, int* cmp, int32_t* cmp_value) {
        retval = nvshmem_int32_wait_until_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z28nvshmem_int32_wait_until_any_nbst = declare_device(
        '_Z28nvshmem_int32_wait_until_any_nbst',
        uint64(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_int32_wait_until_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmem_int32_wait_until_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int32_wait_until_any, CPointer(int32), uint64, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z28nvshmem_int32_wait_until_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_int32_wait_until_any_nbst_caller,
            signature(uint64, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_int32_wait_until_any_nbst(shim_stream, shim_obj)


def int64_wait_until_any():
    pass
    

def _lower__Z28nvshmem_int64_wait_until_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_int64_wait_until_any_nbst(unsigned long &retval , int64_t ** ivars, unsigned long* nelems, int ** status, int* cmp, int64_t* cmp_value) {
        retval = nvshmem_int64_wait_until_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z28nvshmem_int64_wait_until_any_nbst = declare_device(
        '_Z28nvshmem_int64_wait_until_any_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z28nvshmem_int64_wait_until_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmem_int64_wait_until_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int64_wait_until_any, CPointer(int64), uint64, CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z28nvshmem_int64_wait_until_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_int64_wait_until_any_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z28nvshmem_int64_wait_until_any_nbst(shim_stream, shim_obj)


def uint32_wait_until_any():
    pass
    

def _lower__Z29nvshmem_uint32_wait_until_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_uint32_wait_until_any_nbst(unsigned long &retval , uint32_t ** ivars, unsigned long* nelems, int ** status, int* cmp, uint32_t* cmp_value) {
        retval = nvshmem_uint32_wait_until_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_uint32_wait_until_any_nbst = declare_device(
        '_Z29nvshmem_uint32_wait_until_any_nbst',
        uint64(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)
        )
    )
    

    def _Z29nvshmem_uint32_wait_until_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmem_uint32_wait_until_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint32_wait_until_any, CPointer(uint32), uint64, CPointer(int32), int32, uint32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_uint32_wait_until_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_uint32_wait_until_any_nbst_caller,
            signature(uint64, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)),
            ptrs,
        )



_lower__Z29nvshmem_uint32_wait_until_any_nbst(shim_stream, shim_obj)


def uint64_wait_until_any():
    pass
    

def _lower__Z29nvshmem_uint64_wait_until_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_uint64_wait_until_any_nbst(unsigned long &retval , uint64_t ** ivars, unsigned long* nelems, int ** status, int* cmp, uint64_t* cmp_value) {
        retval = nvshmem_uint64_wait_until_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_uint64_wait_until_any_nbst = declare_device(
        '_Z29nvshmem_uint64_wait_until_any_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z29nvshmem_uint64_wait_until_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmem_uint64_wait_until_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint64_wait_until_any, CPointer(uint64), uint64, CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_uint64_wait_until_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_uint64_wait_until_any_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z29nvshmem_uint64_wait_until_any_nbst(shim_stream, shim_obj)


def size_wait_until_any():
    pass
    

def _lower__Z27nvshmem_size_wait_until_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_size_wait_until_any_nbst(unsigned long &retval , unsigned long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long* cmp_value) {
        retval = nvshmem_size_wait_until_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z27nvshmem_size_wait_until_any_nbst = declare_device(
        '_Z27nvshmem_size_wait_until_any_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z27nvshmem_size_wait_until_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmem_size_wait_until_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(size_wait_until_any, CPointer(uint64), uint64, CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z27nvshmem_size_wait_until_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_size_wait_until_any_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z27nvshmem_size_wait_until_any_nbst(shim_stream, shim_obj)


def ptrdiff_wait_until_any():
    pass
    

def _lower__Z30nvshmem_ptrdiff_wait_until_any_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_ptrdiff_wait_until_any_nbst(unsigned long &retval , long ** ivars, unsigned long* nelems, int ** status, int* cmp, long* cmp_value) {
        retval = nvshmem_ptrdiff_wait_until_any(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z30nvshmem_ptrdiff_wait_until_any_nbst = declare_device(
        '_Z30nvshmem_ptrdiff_wait_until_any_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z30nvshmem_ptrdiff_wait_until_any_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmem_ptrdiff_wait_until_any_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ptrdiff_wait_until_any, CPointer(int64), uint64, CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z30nvshmem_ptrdiff_wait_until_any_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_ptrdiff_wait_until_any_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z30nvshmem_ptrdiff_wait_until_any_nbst(shim_stream, shim_obj)


def short_wait_until_some():
    pass
    

def _lower__Z29nvshmem_short_wait_until_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_short_wait_until_some_nbst(unsigned long &retval , short ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, short* cmp_value) {
        retval = nvshmem_short_wait_until_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_short_wait_until_some_nbst = declare_device(
        '_Z29nvshmem_short_wait_until_some_nbst',
        uint64(
            CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int16)
        )
    )
    

    def _Z29nvshmem_short_wait_until_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z29nvshmem_short_wait_until_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(short_wait_until_some, CPointer(int16), uint64, CPointer(uint64), CPointer(int32), int32, int16)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_short_wait_until_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_short_wait_until_some_nbst_caller,
            signature(uint64, CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int16)),
            ptrs,
        )



_lower__Z29nvshmem_short_wait_until_some_nbst(shim_stream, shim_obj)


def int_wait_until_some():
    pass
    

def _lower__Z27nvshmem_int_wait_until_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_int_wait_until_some_nbst(unsigned long &retval , int ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, int* cmp_value) {
        retval = nvshmem_int_wait_until_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z27nvshmem_int_wait_until_some_nbst = declare_device(
        '_Z27nvshmem_int_wait_until_some_nbst',
        uint64(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmem_int_wait_until_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z27nvshmem_int_wait_until_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int_wait_until_some, CPointer(int32), uint64, CPointer(uint64), CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z27nvshmem_int_wait_until_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_int_wait_until_some_nbst_caller,
            signature(uint64, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmem_int_wait_until_some_nbst(shim_stream, shim_obj)


def long_wait_until_some():
    pass
    

def _lower__Z28nvshmem_long_wait_until_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_long_wait_until_some_nbst(unsigned long &retval , long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, long* cmp_value) {
        retval = nvshmem_long_wait_until_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z28nvshmem_long_wait_until_some_nbst = declare_device(
        '_Z28nvshmem_long_wait_until_some_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z28nvshmem_long_wait_until_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z28nvshmem_long_wait_until_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(long_wait_until_some, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z28nvshmem_long_wait_until_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_long_wait_until_some_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z28nvshmem_long_wait_until_some_nbst(shim_stream, shim_obj)


def longlong_wait_until_some():
    pass
    

def _lower__Z32nvshmem_longlong_wait_until_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmem_longlong_wait_until_some_nbst(unsigned long &retval , long long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, long long* cmp_value) {
        retval = nvshmem_longlong_wait_until_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z32nvshmem_longlong_wait_until_some_nbst = declare_device(
        '_Z32nvshmem_longlong_wait_until_some_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z32nvshmem_longlong_wait_until_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z32nvshmem_longlong_wait_until_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(longlong_wait_until_some, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z32nvshmem_longlong_wait_until_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmem_longlong_wait_until_some_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z32nvshmem_longlong_wait_until_some_nbst(shim_stream, shim_obj)


def ushort_wait_until_some():
    pass
    

def _lower__Z30nvshmem_ushort_wait_until_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_ushort_wait_until_some_nbst(unsigned long &retval , unsigned short ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned short* cmp_value) {
        retval = nvshmem_ushort_wait_until_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z30nvshmem_ushort_wait_until_some_nbst = declare_device(
        '_Z30nvshmem_ushort_wait_until_some_nbst',
        uint64(
            CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint16)
        )
    )
    

    def _Z30nvshmem_ushort_wait_until_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z30nvshmem_ushort_wait_until_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ushort_wait_until_some, CPointer(uint16), uint64, CPointer(uint64), CPointer(int32), int32, uint16)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z30nvshmem_ushort_wait_until_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_ushort_wait_until_some_nbst_caller,
            signature(uint64, CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint16)),
            ptrs,
        )



_lower__Z30nvshmem_ushort_wait_until_some_nbst(shim_stream, shim_obj)


def uint_wait_until_some():
    pass
    

def _lower__Z28nvshmem_uint_wait_until_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_uint_wait_until_some_nbst(unsigned long &retval , unsigned int ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned int* cmp_value) {
        retval = nvshmem_uint_wait_until_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z28nvshmem_uint_wait_until_some_nbst = declare_device(
        '_Z28nvshmem_uint_wait_until_some_nbst',
        uint64(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)
        )
    )
    

    def _Z28nvshmem_uint_wait_until_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z28nvshmem_uint_wait_until_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint_wait_until_some, CPointer(uint32), uint64, CPointer(uint64), CPointer(int32), int32, uint32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z28nvshmem_uint_wait_until_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_uint_wait_until_some_nbst_caller,
            signature(uint64, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)),
            ptrs,
        )



_lower__Z28nvshmem_uint_wait_until_some_nbst(shim_stream, shim_obj)


def ulong_wait_until_some():
    pass
    

def _lower__Z29nvshmem_ulong_wait_until_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_ulong_wait_until_some_nbst(unsigned long &retval , unsigned long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned long* cmp_value) {
        retval = nvshmem_ulong_wait_until_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_ulong_wait_until_some_nbst = declare_device(
        '_Z29nvshmem_ulong_wait_until_some_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z29nvshmem_ulong_wait_until_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z29nvshmem_ulong_wait_until_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulong_wait_until_some, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_ulong_wait_until_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_ulong_wait_until_some_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z29nvshmem_ulong_wait_until_some_nbst(shim_stream, shim_obj)


def ulonglong_wait_until_some():
    pass
    

def _lower__Z33nvshmem_ulonglong_wait_until_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmem_ulonglong_wait_until_some_nbst(unsigned long &retval , unsigned long long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned long long* cmp_value) {
        retval = nvshmem_ulonglong_wait_until_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z33nvshmem_ulonglong_wait_until_some_nbst = declare_device(
        '_Z33nvshmem_ulonglong_wait_until_some_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z33nvshmem_ulonglong_wait_until_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z33nvshmem_ulonglong_wait_until_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulonglong_wait_until_some, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z33nvshmem_ulonglong_wait_until_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmem_ulonglong_wait_until_some_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z33nvshmem_ulonglong_wait_until_some_nbst(shim_stream, shim_obj)


def int32_wait_until_some():
    pass
    

def _lower__Z29nvshmem_int32_wait_until_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_int32_wait_until_some_nbst(unsigned long &retval , int32_t ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, int32_t* cmp_value) {
        retval = nvshmem_int32_wait_until_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_int32_wait_until_some_nbst = declare_device(
        '_Z29nvshmem_int32_wait_until_some_nbst',
        uint64(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmem_int32_wait_until_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z29nvshmem_int32_wait_until_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int32_wait_until_some, CPointer(int32), uint64, CPointer(uint64), CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_int32_wait_until_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_int32_wait_until_some_nbst_caller,
            signature(uint64, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmem_int32_wait_until_some_nbst(shim_stream, shim_obj)


def int64_wait_until_some():
    pass
    

def _lower__Z29nvshmem_int64_wait_until_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_int64_wait_until_some_nbst(unsigned long &retval , int64_t ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, int64_t* cmp_value) {
        retval = nvshmem_int64_wait_until_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z29nvshmem_int64_wait_until_some_nbst = declare_device(
        '_Z29nvshmem_int64_wait_until_some_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z29nvshmem_int64_wait_until_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z29nvshmem_int64_wait_until_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int64_wait_until_some, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z29nvshmem_int64_wait_until_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_int64_wait_until_some_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z29nvshmem_int64_wait_until_some_nbst(shim_stream, shim_obj)


def uint32_wait_until_some():
    pass
    

def _lower__Z30nvshmem_uint32_wait_until_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_uint32_wait_until_some_nbst(unsigned long &retval , uint32_t ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, uint32_t* cmp_value) {
        retval = nvshmem_uint32_wait_until_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z30nvshmem_uint32_wait_until_some_nbst = declare_device(
        '_Z30nvshmem_uint32_wait_until_some_nbst',
        uint64(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)
        )
    )
    

    def _Z30nvshmem_uint32_wait_until_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z30nvshmem_uint32_wait_until_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint32_wait_until_some, CPointer(uint32), uint64, CPointer(uint64), CPointer(int32), int32, uint32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z30nvshmem_uint32_wait_until_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_uint32_wait_until_some_nbst_caller,
            signature(uint64, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint32)),
            ptrs,
        )



_lower__Z30nvshmem_uint32_wait_until_some_nbst(shim_stream, shim_obj)


def uint64_wait_until_some():
    pass
    

def _lower__Z30nvshmem_uint64_wait_until_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_uint64_wait_until_some_nbst(unsigned long &retval , uint64_t ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, uint64_t* cmp_value) {
        retval = nvshmem_uint64_wait_until_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z30nvshmem_uint64_wait_until_some_nbst = declare_device(
        '_Z30nvshmem_uint64_wait_until_some_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z30nvshmem_uint64_wait_until_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z30nvshmem_uint64_wait_until_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint64_wait_until_some, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z30nvshmem_uint64_wait_until_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_uint64_wait_until_some_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z30nvshmem_uint64_wait_until_some_nbst(shim_stream, shim_obj)


def size_wait_until_some():
    pass
    

def _lower__Z28nvshmem_size_wait_until_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_size_wait_until_some_nbst(unsigned long &retval , unsigned long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned long* cmp_value) {
        retval = nvshmem_size_wait_until_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z28nvshmem_size_wait_until_some_nbst = declare_device(
        '_Z28nvshmem_size_wait_until_some_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)
        )
    )
    

    def _Z28nvshmem_size_wait_until_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z28nvshmem_size_wait_until_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(size_wait_until_some, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z28nvshmem_size_wait_until_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_size_wait_until_some_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(uint64)),
            ptrs,
        )



_lower__Z28nvshmem_size_wait_until_some_nbst(shim_stream, shim_obj)


def ptrdiff_wait_until_some():
    pass
    

def _lower__Z31nvshmem_ptrdiff_wait_until_some_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmem_ptrdiff_wait_until_some_nbst(unsigned long &retval , long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, long* cmp_value) {
        retval = nvshmem_ptrdiff_wait_until_some(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z31nvshmem_ptrdiff_wait_until_some_nbst = declare_device(
        '_Z31nvshmem_ptrdiff_wait_until_some_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)
        )
    )
    

    def _Z31nvshmem_ptrdiff_wait_until_some_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z31nvshmem_ptrdiff_wait_until_some_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ptrdiff_wait_until_some, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, int64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z31nvshmem_ptrdiff_wait_until_some_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmem_ptrdiff_wait_until_some_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(int64)),
            ptrs,
        )



_lower__Z31nvshmem_ptrdiff_wait_until_some_nbst(shim_stream, shim_obj)


def short_wait_until_all_vector():
    pass
    

def _lower__Z35nvshmem_short_wait_until_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmem_short_wait_until_all_vector_nbst(int &retval , short ** ivars, unsigned long* nelems, int ** status, int* cmp, short ** cmp_value) {
        nvshmem_short_wait_until_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z35nvshmem_short_wait_until_all_vector_nbst = declare_device(
        '_Z35nvshmem_short_wait_until_all_vector_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int16))
        )
    )
    

    def _Z35nvshmem_short_wait_until_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z35nvshmem_short_wait_until_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(short_wait_until_all_vector, CPointer(int16), uint64, CPointer(int32), int32, CPointer(int16))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z35nvshmem_short_wait_until_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmem_short_wait_until_all_vector_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int16))),
            ptrs,
        )



_lower__Z35nvshmem_short_wait_until_all_vector_nbst(shim_stream, shim_obj)


def int_wait_until_all_vector():
    pass
    

def _lower__Z33nvshmem_int_wait_until_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmem_int_wait_until_all_vector_nbst(int &retval , int ** ivars, unsigned long* nelems, int ** status, int* cmp, int ** cmp_value) {
        nvshmem_int_wait_until_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z33nvshmem_int_wait_until_all_vector_nbst = declare_device(
        '_Z33nvshmem_int_wait_until_all_vector_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))
        )
    )
    

    def _Z33nvshmem_int_wait_until_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z33nvshmem_int_wait_until_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int_wait_until_all_vector, CPointer(int32), uint64, CPointer(int32), int32, CPointer(int32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z33nvshmem_int_wait_until_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmem_int_wait_until_all_vector_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))),
            ptrs,
        )



_lower__Z33nvshmem_int_wait_until_all_vector_nbst(shim_stream, shim_obj)


def long_wait_until_all_vector():
    pass
    

def _lower__Z34nvshmem_long_wait_until_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmem_long_wait_until_all_vector_nbst(int &retval , long ** ivars, unsigned long* nelems, int ** status, int* cmp, long ** cmp_value) {
        nvshmem_long_wait_until_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z34nvshmem_long_wait_until_all_vector_nbst = declare_device(
        '_Z34nvshmem_long_wait_until_all_vector_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z34nvshmem_long_wait_until_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z34nvshmem_long_wait_until_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(long_wait_until_all_vector, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z34nvshmem_long_wait_until_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmem_long_wait_until_all_vector_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z34nvshmem_long_wait_until_all_vector_nbst(shim_stream, shim_obj)


def longlong_wait_until_all_vector():
    pass
    

def _lower__Z38nvshmem_longlong_wait_until_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmem_longlong_wait_until_all_vector_nbst(int &retval , long long ** ivars, unsigned long* nelems, int ** status, int* cmp, long long ** cmp_value) {
        nvshmem_longlong_wait_until_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z38nvshmem_longlong_wait_until_all_vector_nbst = declare_device(
        '_Z38nvshmem_longlong_wait_until_all_vector_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z38nvshmem_longlong_wait_until_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z38nvshmem_longlong_wait_until_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(longlong_wait_until_all_vector, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z38nvshmem_longlong_wait_until_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmem_longlong_wait_until_all_vector_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z38nvshmem_longlong_wait_until_all_vector_nbst(shim_stream, shim_obj)


def ushort_wait_until_all_vector():
    pass
    

def _lower__Z36nvshmem_ushort_wait_until_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmem_ushort_wait_until_all_vector_nbst(int &retval , unsigned short ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned short ** cmp_value) {
        nvshmem_ushort_wait_until_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z36nvshmem_ushort_wait_until_all_vector_nbst = declare_device(
        '_Z36nvshmem_ushort_wait_until_all_vector_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint16))
        )
    )
    

    def _Z36nvshmem_ushort_wait_until_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z36nvshmem_ushort_wait_until_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ushort_wait_until_all_vector, CPointer(uint16), uint64, CPointer(int32), int32, CPointer(uint16))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z36nvshmem_ushort_wait_until_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmem_ushort_wait_until_all_vector_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint16))),
            ptrs,
        )



_lower__Z36nvshmem_ushort_wait_until_all_vector_nbst(shim_stream, shim_obj)


def uint_wait_until_all_vector():
    pass
    

def _lower__Z34nvshmem_uint_wait_until_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmem_uint_wait_until_all_vector_nbst(int &retval , unsigned int ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned int ** cmp_value) {
        nvshmem_uint_wait_until_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z34nvshmem_uint_wait_until_all_vector_nbst = declare_device(
        '_Z34nvshmem_uint_wait_until_all_vector_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))
        )
    )
    

    def _Z34nvshmem_uint_wait_until_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z34nvshmem_uint_wait_until_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint_wait_until_all_vector, CPointer(uint32), uint64, CPointer(int32), int32, CPointer(uint32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z34nvshmem_uint_wait_until_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmem_uint_wait_until_all_vector_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))),
            ptrs,
        )



_lower__Z34nvshmem_uint_wait_until_all_vector_nbst(shim_stream, shim_obj)


def ulong_wait_until_all_vector():
    pass
    

def _lower__Z35nvshmem_ulong_wait_until_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmem_ulong_wait_until_all_vector_nbst(int &retval , unsigned long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long ** cmp_value) {
        nvshmem_ulong_wait_until_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z35nvshmem_ulong_wait_until_all_vector_nbst = declare_device(
        '_Z35nvshmem_ulong_wait_until_all_vector_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z35nvshmem_ulong_wait_until_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z35nvshmem_ulong_wait_until_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulong_wait_until_all_vector, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z35nvshmem_ulong_wait_until_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmem_ulong_wait_until_all_vector_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z35nvshmem_ulong_wait_until_all_vector_nbst(shim_stream, shim_obj)


def ulonglong_wait_until_all_vector():
    pass
    

def _lower__Z39nvshmem_ulonglong_wait_until_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z39nvshmem_ulonglong_wait_until_all_vector_nbst(int &retval , unsigned long long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long long ** cmp_value) {
        nvshmem_ulonglong_wait_until_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z39nvshmem_ulonglong_wait_until_all_vector_nbst = declare_device(
        '_Z39nvshmem_ulonglong_wait_until_all_vector_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z39nvshmem_ulonglong_wait_until_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z39nvshmem_ulonglong_wait_until_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulonglong_wait_until_all_vector, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z39nvshmem_ulonglong_wait_until_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z39nvshmem_ulonglong_wait_until_all_vector_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z39nvshmem_ulonglong_wait_until_all_vector_nbst(shim_stream, shim_obj)


def int32_wait_until_all_vector():
    pass
    

def _lower__Z35nvshmem_int32_wait_until_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmem_int32_wait_until_all_vector_nbst(int &retval , int32_t ** ivars, unsigned long* nelems, int ** status, int* cmp, int32_t ** cmp_value) {
        nvshmem_int32_wait_until_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z35nvshmem_int32_wait_until_all_vector_nbst = declare_device(
        '_Z35nvshmem_int32_wait_until_all_vector_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))
        )
    )
    

    def _Z35nvshmem_int32_wait_until_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z35nvshmem_int32_wait_until_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int32_wait_until_all_vector, CPointer(int32), uint64, CPointer(int32), int32, CPointer(int32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z35nvshmem_int32_wait_until_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmem_int32_wait_until_all_vector_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))),
            ptrs,
        )



_lower__Z35nvshmem_int32_wait_until_all_vector_nbst(shim_stream, shim_obj)


def int64_wait_until_all_vector():
    pass
    

def _lower__Z35nvshmem_int64_wait_until_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmem_int64_wait_until_all_vector_nbst(int &retval , int64_t ** ivars, unsigned long* nelems, int ** status, int* cmp, int64_t ** cmp_value) {
        nvshmem_int64_wait_until_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z35nvshmem_int64_wait_until_all_vector_nbst = declare_device(
        '_Z35nvshmem_int64_wait_until_all_vector_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z35nvshmem_int64_wait_until_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z35nvshmem_int64_wait_until_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int64_wait_until_all_vector, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z35nvshmem_int64_wait_until_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmem_int64_wait_until_all_vector_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z35nvshmem_int64_wait_until_all_vector_nbst(shim_stream, shim_obj)


def uint32_wait_until_all_vector():
    pass
    

def _lower__Z36nvshmem_uint32_wait_until_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmem_uint32_wait_until_all_vector_nbst(int &retval , uint32_t ** ivars, unsigned long* nelems, int ** status, int* cmp, uint32_t ** cmp_value) {
        nvshmem_uint32_wait_until_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z36nvshmem_uint32_wait_until_all_vector_nbst = declare_device(
        '_Z36nvshmem_uint32_wait_until_all_vector_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))
        )
    )
    

    def _Z36nvshmem_uint32_wait_until_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z36nvshmem_uint32_wait_until_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint32_wait_until_all_vector, CPointer(uint32), uint64, CPointer(int32), int32, CPointer(uint32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z36nvshmem_uint32_wait_until_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmem_uint32_wait_until_all_vector_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))),
            ptrs,
        )



_lower__Z36nvshmem_uint32_wait_until_all_vector_nbst(shim_stream, shim_obj)


def uint64_wait_until_all_vector():
    pass
    

def _lower__Z36nvshmem_uint64_wait_until_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmem_uint64_wait_until_all_vector_nbst(int &retval , uint64_t ** ivars, unsigned long* nelems, int ** status, int* cmp, uint64_t ** cmp_value) {
        nvshmem_uint64_wait_until_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z36nvshmem_uint64_wait_until_all_vector_nbst = declare_device(
        '_Z36nvshmem_uint64_wait_until_all_vector_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z36nvshmem_uint64_wait_until_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z36nvshmem_uint64_wait_until_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint64_wait_until_all_vector, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z36nvshmem_uint64_wait_until_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmem_uint64_wait_until_all_vector_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z36nvshmem_uint64_wait_until_all_vector_nbst(shim_stream, shim_obj)


def size_wait_until_all_vector():
    pass
    

def _lower__Z34nvshmem_size_wait_until_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmem_size_wait_until_all_vector_nbst(int &retval , unsigned long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long ** cmp_value) {
        nvshmem_size_wait_until_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z34nvshmem_size_wait_until_all_vector_nbst = declare_device(
        '_Z34nvshmem_size_wait_until_all_vector_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z34nvshmem_size_wait_until_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z34nvshmem_size_wait_until_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(size_wait_until_all_vector, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z34nvshmem_size_wait_until_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmem_size_wait_until_all_vector_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z34nvshmem_size_wait_until_all_vector_nbst(shim_stream, shim_obj)


def ptrdiff_wait_until_all_vector():
    pass
    

def _lower__Z37nvshmem_ptrdiff_wait_until_all_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmem_ptrdiff_wait_until_all_vector_nbst(int &retval , long ** ivars, unsigned long* nelems, int ** status, int* cmp, long ** cmp_value) {
        nvshmem_ptrdiff_wait_until_all_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z37nvshmem_ptrdiff_wait_until_all_vector_nbst = declare_device(
        '_Z37nvshmem_ptrdiff_wait_until_all_vector_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z37nvshmem_ptrdiff_wait_until_all_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z37nvshmem_ptrdiff_wait_until_all_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ptrdiff_wait_until_all_vector, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z37nvshmem_ptrdiff_wait_until_all_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmem_ptrdiff_wait_until_all_vector_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z37nvshmem_ptrdiff_wait_until_all_vector_nbst(shim_stream, shim_obj)


def short_wait_until_any_vector():
    pass
    

def _lower__Z35nvshmem_short_wait_until_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmem_short_wait_until_any_vector_nbst(unsigned long &retval , short ** ivars, unsigned long* nelems, int ** status, int* cmp, short ** cmp_value) {
        retval = nvshmem_short_wait_until_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z35nvshmem_short_wait_until_any_vector_nbst = declare_device(
        '_Z35nvshmem_short_wait_until_any_vector_nbst',
        uint64(
            CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int16))
        )
    )
    

    def _Z35nvshmem_short_wait_until_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z35nvshmem_short_wait_until_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(short_wait_until_any_vector, CPointer(int16), uint64, CPointer(int32), int32, CPointer(int16))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z35nvshmem_short_wait_until_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmem_short_wait_until_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int16))),
            ptrs,
        )



_lower__Z35nvshmem_short_wait_until_any_vector_nbst(shim_stream, shim_obj)


def int_wait_until_any_vector():
    pass
    

def _lower__Z33nvshmem_int_wait_until_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmem_int_wait_until_any_vector_nbst(unsigned long &retval , int ** ivars, unsigned long* nelems, int ** status, int* cmp, int ** cmp_value) {
        retval = nvshmem_int_wait_until_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z33nvshmem_int_wait_until_any_vector_nbst = declare_device(
        '_Z33nvshmem_int_wait_until_any_vector_nbst',
        uint64(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))
        )
    )
    

    def _Z33nvshmem_int_wait_until_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z33nvshmem_int_wait_until_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int_wait_until_any_vector, CPointer(int32), uint64, CPointer(int32), int32, CPointer(int32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z33nvshmem_int_wait_until_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmem_int_wait_until_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))),
            ptrs,
        )



_lower__Z33nvshmem_int_wait_until_any_vector_nbst(shim_stream, shim_obj)


def long_wait_until_any_vector():
    pass
    

def _lower__Z34nvshmem_long_wait_until_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmem_long_wait_until_any_vector_nbst(unsigned long &retval , long ** ivars, unsigned long* nelems, int ** status, int* cmp, long ** cmp_value) {
        retval = nvshmem_long_wait_until_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z34nvshmem_long_wait_until_any_vector_nbst = declare_device(
        '_Z34nvshmem_long_wait_until_any_vector_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z34nvshmem_long_wait_until_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z34nvshmem_long_wait_until_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(long_wait_until_any_vector, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z34nvshmem_long_wait_until_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmem_long_wait_until_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z34nvshmem_long_wait_until_any_vector_nbst(shim_stream, shim_obj)


def longlong_wait_until_any_vector():
    pass
    

def _lower__Z38nvshmem_longlong_wait_until_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmem_longlong_wait_until_any_vector_nbst(unsigned long &retval , long long ** ivars, unsigned long* nelems, int ** status, int* cmp, long long ** cmp_value) {
        retval = nvshmem_longlong_wait_until_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z38nvshmem_longlong_wait_until_any_vector_nbst = declare_device(
        '_Z38nvshmem_longlong_wait_until_any_vector_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z38nvshmem_longlong_wait_until_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z38nvshmem_longlong_wait_until_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(longlong_wait_until_any_vector, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z38nvshmem_longlong_wait_until_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmem_longlong_wait_until_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z38nvshmem_longlong_wait_until_any_vector_nbst(shim_stream, shim_obj)


def ushort_wait_until_any_vector():
    pass
    

def _lower__Z36nvshmem_ushort_wait_until_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmem_ushort_wait_until_any_vector_nbst(unsigned long &retval , unsigned short ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned short ** cmp_value) {
        retval = nvshmem_ushort_wait_until_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z36nvshmem_ushort_wait_until_any_vector_nbst = declare_device(
        '_Z36nvshmem_ushort_wait_until_any_vector_nbst',
        uint64(
            CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint16))
        )
    )
    

    def _Z36nvshmem_ushort_wait_until_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z36nvshmem_ushort_wait_until_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ushort_wait_until_any_vector, CPointer(uint16), uint64, CPointer(int32), int32, CPointer(uint16))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z36nvshmem_ushort_wait_until_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmem_ushort_wait_until_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint16))),
            ptrs,
        )



_lower__Z36nvshmem_ushort_wait_until_any_vector_nbst(shim_stream, shim_obj)


def uint_wait_until_any_vector():
    pass
    

def _lower__Z34nvshmem_uint_wait_until_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmem_uint_wait_until_any_vector_nbst(unsigned long &retval , unsigned int ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned int ** cmp_value) {
        retval = nvshmem_uint_wait_until_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z34nvshmem_uint_wait_until_any_vector_nbst = declare_device(
        '_Z34nvshmem_uint_wait_until_any_vector_nbst',
        uint64(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))
        )
    )
    

    def _Z34nvshmem_uint_wait_until_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z34nvshmem_uint_wait_until_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint_wait_until_any_vector, CPointer(uint32), uint64, CPointer(int32), int32, CPointer(uint32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z34nvshmem_uint_wait_until_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmem_uint_wait_until_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))),
            ptrs,
        )



_lower__Z34nvshmem_uint_wait_until_any_vector_nbst(shim_stream, shim_obj)


def ulong_wait_until_any_vector():
    pass
    

def _lower__Z35nvshmem_ulong_wait_until_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmem_ulong_wait_until_any_vector_nbst(unsigned long &retval , unsigned long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long ** cmp_value) {
        retval = nvshmem_ulong_wait_until_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z35nvshmem_ulong_wait_until_any_vector_nbst = declare_device(
        '_Z35nvshmem_ulong_wait_until_any_vector_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z35nvshmem_ulong_wait_until_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z35nvshmem_ulong_wait_until_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulong_wait_until_any_vector, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z35nvshmem_ulong_wait_until_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmem_ulong_wait_until_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z35nvshmem_ulong_wait_until_any_vector_nbst(shim_stream, shim_obj)


def ulonglong_wait_until_any_vector():
    pass
    

def _lower__Z39nvshmem_ulonglong_wait_until_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z39nvshmem_ulonglong_wait_until_any_vector_nbst(unsigned long &retval , unsigned long long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long long ** cmp_value) {
        retval = nvshmem_ulonglong_wait_until_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z39nvshmem_ulonglong_wait_until_any_vector_nbst = declare_device(
        '_Z39nvshmem_ulonglong_wait_until_any_vector_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z39nvshmem_ulonglong_wait_until_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z39nvshmem_ulonglong_wait_until_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulonglong_wait_until_any_vector, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z39nvshmem_ulonglong_wait_until_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z39nvshmem_ulonglong_wait_until_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z39nvshmem_ulonglong_wait_until_any_vector_nbst(shim_stream, shim_obj)


def int32_wait_until_any_vector():
    pass
    

def _lower__Z35nvshmem_int32_wait_until_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmem_int32_wait_until_any_vector_nbst(unsigned long &retval , int32_t ** ivars, unsigned long* nelems, int ** status, int* cmp, int32_t ** cmp_value) {
        retval = nvshmem_int32_wait_until_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z35nvshmem_int32_wait_until_any_vector_nbst = declare_device(
        '_Z35nvshmem_int32_wait_until_any_vector_nbst',
        uint64(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))
        )
    )
    

    def _Z35nvshmem_int32_wait_until_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z35nvshmem_int32_wait_until_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int32_wait_until_any_vector, CPointer(int32), uint64, CPointer(int32), int32, CPointer(int32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z35nvshmem_int32_wait_until_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmem_int32_wait_until_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))),
            ptrs,
        )



_lower__Z35nvshmem_int32_wait_until_any_vector_nbst(shim_stream, shim_obj)


def int64_wait_until_any_vector():
    pass
    

def _lower__Z35nvshmem_int64_wait_until_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmem_int64_wait_until_any_vector_nbst(unsigned long &retval , int64_t ** ivars, unsigned long* nelems, int ** status, int* cmp, int64_t ** cmp_value) {
        retval = nvshmem_int64_wait_until_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z35nvshmem_int64_wait_until_any_vector_nbst = declare_device(
        '_Z35nvshmem_int64_wait_until_any_vector_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z35nvshmem_int64_wait_until_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z35nvshmem_int64_wait_until_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int64_wait_until_any_vector, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z35nvshmem_int64_wait_until_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmem_int64_wait_until_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z35nvshmem_int64_wait_until_any_vector_nbst(shim_stream, shim_obj)


def uint32_wait_until_any_vector():
    pass
    

def _lower__Z36nvshmem_uint32_wait_until_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmem_uint32_wait_until_any_vector_nbst(unsigned long &retval , uint32_t ** ivars, unsigned long* nelems, int ** status, int* cmp, uint32_t ** cmp_value) {
        retval = nvshmem_uint32_wait_until_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z36nvshmem_uint32_wait_until_any_vector_nbst = declare_device(
        '_Z36nvshmem_uint32_wait_until_any_vector_nbst',
        uint64(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))
        )
    )
    

    def _Z36nvshmem_uint32_wait_until_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z36nvshmem_uint32_wait_until_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint32_wait_until_any_vector, CPointer(uint32), uint64, CPointer(int32), int32, CPointer(uint32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z36nvshmem_uint32_wait_until_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmem_uint32_wait_until_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))),
            ptrs,
        )



_lower__Z36nvshmem_uint32_wait_until_any_vector_nbst(shim_stream, shim_obj)


def uint64_wait_until_any_vector():
    pass
    

def _lower__Z36nvshmem_uint64_wait_until_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmem_uint64_wait_until_any_vector_nbst(unsigned long &retval , uint64_t ** ivars, unsigned long* nelems, int ** status, int* cmp, uint64_t ** cmp_value) {
        retval = nvshmem_uint64_wait_until_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z36nvshmem_uint64_wait_until_any_vector_nbst = declare_device(
        '_Z36nvshmem_uint64_wait_until_any_vector_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z36nvshmem_uint64_wait_until_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z36nvshmem_uint64_wait_until_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint64_wait_until_any_vector, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z36nvshmem_uint64_wait_until_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmem_uint64_wait_until_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z36nvshmem_uint64_wait_until_any_vector_nbst(shim_stream, shim_obj)


def size_wait_until_any_vector():
    pass
    

def _lower__Z34nvshmem_size_wait_until_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmem_size_wait_until_any_vector_nbst(unsigned long &retval , unsigned long ** ivars, unsigned long* nelems, int ** status, int* cmp, unsigned long ** cmp_value) {
        retval = nvshmem_size_wait_until_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z34nvshmem_size_wait_until_any_vector_nbst = declare_device(
        '_Z34nvshmem_size_wait_until_any_vector_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z34nvshmem_size_wait_until_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z34nvshmem_size_wait_until_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(size_wait_until_any_vector, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z34nvshmem_size_wait_until_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmem_size_wait_until_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z34nvshmem_size_wait_until_any_vector_nbst(shim_stream, shim_obj)


def ptrdiff_wait_until_any_vector():
    pass
    

def _lower__Z37nvshmem_ptrdiff_wait_until_any_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmem_ptrdiff_wait_until_any_vector_nbst(unsigned long &retval , long ** ivars, unsigned long* nelems, int ** status, int* cmp, long ** cmp_value) {
        retval = nvshmem_ptrdiff_wait_until_any_vector(*ivars, *nelems, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z37nvshmem_ptrdiff_wait_until_any_vector_nbst = declare_device(
        '_Z37nvshmem_ptrdiff_wait_until_any_vector_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z37nvshmem_ptrdiff_wait_until_any_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z37nvshmem_ptrdiff_wait_until_any_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ptrdiff_wait_until_any_vector, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z37nvshmem_ptrdiff_wait_until_any_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmem_ptrdiff_wait_until_any_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z37nvshmem_ptrdiff_wait_until_any_vector_nbst(shim_stream, shim_obj)


def short_wait_until_some_vector():
    pass
    

def _lower__Z36nvshmem_short_wait_until_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmem_short_wait_until_some_vector_nbst(unsigned long &retval , short ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, short ** cmp_value) {
        retval = nvshmem_short_wait_until_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z36nvshmem_short_wait_until_some_vector_nbst = declare_device(
        '_Z36nvshmem_short_wait_until_some_vector_nbst',
        uint64(
            CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int16))
        )
    )
    

    def _Z36nvshmem_short_wait_until_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z36nvshmem_short_wait_until_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(short_wait_until_some_vector, CPointer(int16), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int16))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z36nvshmem_short_wait_until_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmem_short_wait_until_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int16))),
            ptrs,
        )



_lower__Z36nvshmem_short_wait_until_some_vector_nbst(shim_stream, shim_obj)


def int_wait_until_some_vector():
    pass
    

def _lower__Z34nvshmem_int_wait_until_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmem_int_wait_until_some_vector_nbst(unsigned long &retval , int ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, int ** cmp_value) {
        retval = nvshmem_int_wait_until_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z34nvshmem_int_wait_until_some_vector_nbst = declare_device(
        '_Z34nvshmem_int_wait_until_some_vector_nbst',
        uint64(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))
        )
    )
    

    def _Z34nvshmem_int_wait_until_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z34nvshmem_int_wait_until_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int_wait_until_some_vector, CPointer(int32), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z34nvshmem_int_wait_until_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmem_int_wait_until_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))),
            ptrs,
        )



_lower__Z34nvshmem_int_wait_until_some_vector_nbst(shim_stream, shim_obj)


def long_wait_until_some_vector():
    pass
    

def _lower__Z35nvshmem_long_wait_until_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmem_long_wait_until_some_vector_nbst(unsigned long &retval , long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, long ** cmp_value) {
        retval = nvshmem_long_wait_until_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z35nvshmem_long_wait_until_some_vector_nbst = declare_device(
        '_Z35nvshmem_long_wait_until_some_vector_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z35nvshmem_long_wait_until_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z35nvshmem_long_wait_until_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(long_wait_until_some_vector, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z35nvshmem_long_wait_until_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmem_long_wait_until_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z35nvshmem_long_wait_until_some_vector_nbst(shim_stream, shim_obj)


def longlong_wait_until_some_vector():
    pass
    

def _lower__Z39nvshmem_longlong_wait_until_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z39nvshmem_longlong_wait_until_some_vector_nbst(unsigned long &retval , long long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, long long ** cmp_value) {
        retval = nvshmem_longlong_wait_until_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z39nvshmem_longlong_wait_until_some_vector_nbst = declare_device(
        '_Z39nvshmem_longlong_wait_until_some_vector_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z39nvshmem_longlong_wait_until_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z39nvshmem_longlong_wait_until_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(longlong_wait_until_some_vector, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z39nvshmem_longlong_wait_until_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z39nvshmem_longlong_wait_until_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z39nvshmem_longlong_wait_until_some_vector_nbst(shim_stream, shim_obj)


def ushort_wait_until_some_vector():
    pass
    

def _lower__Z37nvshmem_ushort_wait_until_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmem_ushort_wait_until_some_vector_nbst(unsigned long &retval , unsigned short ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned short ** cmp_value) {
        retval = nvshmem_ushort_wait_until_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z37nvshmem_ushort_wait_until_some_vector_nbst = declare_device(
        '_Z37nvshmem_ushort_wait_until_some_vector_nbst',
        uint64(
            CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint16))
        )
    )
    

    def _Z37nvshmem_ushort_wait_until_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z37nvshmem_ushort_wait_until_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ushort_wait_until_some_vector, CPointer(uint16), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint16))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z37nvshmem_ushort_wait_until_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmem_ushort_wait_until_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint16))),
            ptrs,
        )



_lower__Z37nvshmem_ushort_wait_until_some_vector_nbst(shim_stream, shim_obj)


def uint_wait_until_some_vector():
    pass
    

def _lower__Z35nvshmem_uint_wait_until_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmem_uint_wait_until_some_vector_nbst(unsigned long &retval , unsigned int ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned int ** cmp_value) {
        retval = nvshmem_uint_wait_until_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z35nvshmem_uint_wait_until_some_vector_nbst = declare_device(
        '_Z35nvshmem_uint_wait_until_some_vector_nbst',
        uint64(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))
        )
    )
    

    def _Z35nvshmem_uint_wait_until_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z35nvshmem_uint_wait_until_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint_wait_until_some_vector, CPointer(uint32), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z35nvshmem_uint_wait_until_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmem_uint_wait_until_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))),
            ptrs,
        )



_lower__Z35nvshmem_uint_wait_until_some_vector_nbst(shim_stream, shim_obj)


def ulong_wait_until_some_vector():
    pass
    

def _lower__Z36nvshmem_ulong_wait_until_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmem_ulong_wait_until_some_vector_nbst(unsigned long &retval , unsigned long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned long ** cmp_value) {
        retval = nvshmem_ulong_wait_until_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z36nvshmem_ulong_wait_until_some_vector_nbst = declare_device(
        '_Z36nvshmem_ulong_wait_until_some_vector_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z36nvshmem_ulong_wait_until_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z36nvshmem_ulong_wait_until_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulong_wait_until_some_vector, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z36nvshmem_ulong_wait_until_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmem_ulong_wait_until_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z36nvshmem_ulong_wait_until_some_vector_nbst(shim_stream, shim_obj)


def ulonglong_wait_until_some_vector():
    pass
    

def _lower__Z40nvshmem_ulonglong_wait_until_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z40nvshmem_ulonglong_wait_until_some_vector_nbst(unsigned long &retval , unsigned long long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned long long ** cmp_value) {
        retval = nvshmem_ulonglong_wait_until_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z40nvshmem_ulonglong_wait_until_some_vector_nbst = declare_device(
        '_Z40nvshmem_ulonglong_wait_until_some_vector_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z40nvshmem_ulonglong_wait_until_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z40nvshmem_ulonglong_wait_until_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulonglong_wait_until_some_vector, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z40nvshmem_ulonglong_wait_until_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z40nvshmem_ulonglong_wait_until_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z40nvshmem_ulonglong_wait_until_some_vector_nbst(shim_stream, shim_obj)


def int32_wait_until_some_vector():
    pass
    

def _lower__Z36nvshmem_int32_wait_until_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmem_int32_wait_until_some_vector_nbst(unsigned long &retval , int32_t ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, int32_t ** cmp_value) {
        retval = nvshmem_int32_wait_until_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z36nvshmem_int32_wait_until_some_vector_nbst = declare_device(
        '_Z36nvshmem_int32_wait_until_some_vector_nbst',
        uint64(
            CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))
        )
    )
    

    def _Z36nvshmem_int32_wait_until_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z36nvshmem_int32_wait_until_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int32_wait_until_some_vector, CPointer(int32), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z36nvshmem_int32_wait_until_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmem_int32_wait_until_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int32))),
            ptrs,
        )



_lower__Z36nvshmem_int32_wait_until_some_vector_nbst(shim_stream, shim_obj)


def int64_wait_until_some_vector():
    pass
    

def _lower__Z36nvshmem_int64_wait_until_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmem_int64_wait_until_some_vector_nbst(unsigned long &retval , int64_t ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, int64_t ** cmp_value) {
        retval = nvshmem_int64_wait_until_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z36nvshmem_int64_wait_until_some_vector_nbst = declare_device(
        '_Z36nvshmem_int64_wait_until_some_vector_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z36nvshmem_int64_wait_until_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z36nvshmem_int64_wait_until_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int64_wait_until_some_vector, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z36nvshmem_int64_wait_until_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmem_int64_wait_until_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z36nvshmem_int64_wait_until_some_vector_nbst(shim_stream, shim_obj)


def uint32_wait_until_some_vector():
    pass
    

def _lower__Z37nvshmem_uint32_wait_until_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmem_uint32_wait_until_some_vector_nbst(unsigned long &retval , uint32_t ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, uint32_t ** cmp_value) {
        retval = nvshmem_uint32_wait_until_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z37nvshmem_uint32_wait_until_some_vector_nbst = declare_device(
        '_Z37nvshmem_uint32_wait_until_some_vector_nbst',
        uint64(
            CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))
        )
    )
    

    def _Z37nvshmem_uint32_wait_until_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z37nvshmem_uint32_wait_until_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint32_wait_until_some_vector, CPointer(uint32), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z37nvshmem_uint32_wait_until_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmem_uint32_wait_until_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint32))),
            ptrs,
        )



_lower__Z37nvshmem_uint32_wait_until_some_vector_nbst(shim_stream, shim_obj)


def uint64_wait_until_some_vector():
    pass
    

def _lower__Z37nvshmem_uint64_wait_until_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmem_uint64_wait_until_some_vector_nbst(unsigned long &retval , uint64_t ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, uint64_t ** cmp_value) {
        retval = nvshmem_uint64_wait_until_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z37nvshmem_uint64_wait_until_some_vector_nbst = declare_device(
        '_Z37nvshmem_uint64_wait_until_some_vector_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z37nvshmem_uint64_wait_until_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z37nvshmem_uint64_wait_until_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint64_wait_until_some_vector, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z37nvshmem_uint64_wait_until_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmem_uint64_wait_until_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z37nvshmem_uint64_wait_until_some_vector_nbst(shim_stream, shim_obj)


def size_wait_until_some_vector():
    pass
    

def _lower__Z35nvshmem_size_wait_until_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmem_size_wait_until_some_vector_nbst(unsigned long &retval , unsigned long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, unsigned long ** cmp_value) {
        retval = nvshmem_size_wait_until_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z35nvshmem_size_wait_until_some_vector_nbst = declare_device(
        '_Z35nvshmem_size_wait_until_some_vector_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))
        )
    )
    

    def _Z35nvshmem_size_wait_until_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z35nvshmem_size_wait_until_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(size_wait_until_some_vector, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z35nvshmem_size_wait_until_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmem_size_wait_until_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(uint64))),
            ptrs,
        )



_lower__Z35nvshmem_size_wait_until_some_vector_nbst(shim_stream, shim_obj)


def ptrdiff_wait_until_some_vector():
    pass
    

def _lower__Z38nvshmem_ptrdiff_wait_until_some_vector_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmem_ptrdiff_wait_until_some_vector_nbst(unsigned long &retval , long ** ivars, unsigned long* nelems, unsigned long ** indices, int ** status, int* cmp, long ** cmp_value) {
        retval = nvshmem_ptrdiff_wait_until_some_vector(*ivars, *nelems, *indices, *status, *cmp, *cmp_value);
        return 0;
    }
        """


    _Z38nvshmem_ptrdiff_wait_until_some_vector_nbst = declare_device(
        '_Z38nvshmem_ptrdiff_wait_until_some_vector_nbst',
        uint64(
            CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))
        )
    )
    

    def _Z38nvshmem_ptrdiff_wait_until_some_vector_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z38nvshmem_ptrdiff_wait_until_some_vector_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ptrdiff_wait_until_some_vector, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int64))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_Z38nvshmem_ptrdiff_wait_until_some_vector_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmem_ptrdiff_wait_until_some_vector_nbst_caller,
            signature(uint64, CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(CPointer(int32)), CPointer(int32), CPointer(CPointer(int64))),
            ptrs,
        )



_lower__Z38nvshmem_ptrdiff_wait_until_some_vector_nbst(shim_stream, shim_obj)


def quiet():
    pass
    

def _lower__Z13nvshmem_quiet_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z13nvshmem_quiet_nbst(int &retval ) {
        nvshmem_quiet();
        return 0;
    }
        """


    _Z13nvshmem_quiet_nbst = declare_device(
        '_Z13nvshmem_quiet_nbst',
        void(
        
        )
    )
    

    def _Z13nvshmem_quiet_nbst_caller():
        return _Z13nvshmem_quiet_nbst()
    

    @lower(quiet, )
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z13nvshmem_quiet_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z13nvshmem_quiet_nbst_caller,
            signature(void, ),
            ptrs,
        )



_lower__Z13nvshmem_quiet_nbst(shim_stream, shim_obj)


def fence():
    pass
    

def _lower__Z13nvshmem_fence_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z13nvshmem_fence_nbst(int &retval ) {
        nvshmem_fence();
        return 0;
    }
        """


    _Z13nvshmem_fence_nbst = declare_device(
        '_Z13nvshmem_fence_nbst',
        void(
        
        )
    )
    

    def _Z13nvshmem_fence_nbst_caller():
        return _Z13nvshmem_fence_nbst()
    

    @lower(fence, )
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z13nvshmem_fence_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z13nvshmem_fence_nbst_caller,
            signature(void, ),
            ptrs,
        )



_lower__Z13nvshmem_fence_nbst(shim_stream, shim_obj)


def int_atomic_fetch_add():
    pass
    

def _lower__Z28nvshmem_int_atomic_fetch_add_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_int_atomic_fetch_add_nbst(int &retval , int ** target, int* value, int* pe) {
        retval = nvshmem_int_atomic_fetch_add(*target, *value, *pe);
        return 0;
    }
        """


    _Z28nvshmem_int_atomic_fetch_add_nbst = declare_device(
        '_Z28nvshmem_int_atomic_fetch_add_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_int_atomic_fetch_add_nbst_caller(arg_0, arg_1, arg_2):
        return _Z28nvshmem_int_atomic_fetch_add_nbst(arg_0, arg_1, arg_2)
    

    @lower(int_atomic_fetch_add, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_int_atomic_fetch_add_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_int_atomic_fetch_add_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_int_atomic_fetch_add_nbst(shim_stream, shim_obj)


def long_atomic_fetch_add():
    pass
    

def _lower__Z29nvshmem_long_atomic_fetch_add_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_long_atomic_fetch_add_nbst(long &retval , long ** target, long* value, int* pe) {
        retval = nvshmem_long_atomic_fetch_add(*target, *value, *pe);
        return 0;
    }
        """


    _Z29nvshmem_long_atomic_fetch_add_nbst = declare_device(
        '_Z29nvshmem_long_atomic_fetch_add_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z29nvshmem_long_atomic_fetch_add_nbst_caller(arg_0, arg_1, arg_2):
        return _Z29nvshmem_long_atomic_fetch_add_nbst(arg_0, arg_1, arg_2)
    

    @lower(long_atomic_fetch_add, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmem_long_atomic_fetch_add_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_long_atomic_fetch_add_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmem_long_atomic_fetch_add_nbst(shim_stream, shim_obj)


def uint_atomic_fetch_add():
    pass
    

def _lower__Z29nvshmem_uint_atomic_fetch_add_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_uint_atomic_fetch_add_nbst(unsigned int &retval , unsigned int ** target, unsigned int* value, int* pe) {
        retval = nvshmem_uint_atomic_fetch_add(*target, *value, *pe);
        return 0;
    }
        """


    _Z29nvshmem_uint_atomic_fetch_add_nbst = declare_device(
        '_Z29nvshmem_uint_atomic_fetch_add_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z29nvshmem_uint_atomic_fetch_add_nbst_caller(arg_0, arg_1, arg_2):
        return _Z29nvshmem_uint_atomic_fetch_add_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint_atomic_fetch_add, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmem_uint_atomic_fetch_add_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_uint_atomic_fetch_add_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmem_uint_atomic_fetch_add_nbst(shim_stream, shim_obj)


def ulong_atomic_fetch_add():
    pass
    

def _lower__Z30nvshmem_ulong_atomic_fetch_add_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_ulong_atomic_fetch_add_nbst(unsigned long &retval , unsigned long ** target, unsigned long* value, int* pe) {
        retval = nvshmem_ulong_atomic_fetch_add(*target, *value, *pe);
        return 0;
    }
        """


    _Z30nvshmem_ulong_atomic_fetch_add_nbst = declare_device(
        '_Z30nvshmem_ulong_atomic_fetch_add_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z30nvshmem_ulong_atomic_fetch_add_nbst_caller(arg_0, arg_1, arg_2):
        return _Z30nvshmem_ulong_atomic_fetch_add_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulong_atomic_fetch_add, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmem_ulong_atomic_fetch_add_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_ulong_atomic_fetch_add_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmem_ulong_atomic_fetch_add_nbst(shim_stream, shim_obj)


def ulonglong_atomic_fetch_add():
    pass
    

def _lower__Z34nvshmem_ulonglong_atomic_fetch_add_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmem_ulonglong_atomic_fetch_add_nbst(unsigned long long &retval , unsigned long long ** target, unsigned long long* value, int* pe) {
        retval = nvshmem_ulonglong_atomic_fetch_add(*target, *value, *pe);
        return 0;
    }
        """


    _Z34nvshmem_ulonglong_atomic_fetch_add_nbst = declare_device(
        '_Z34nvshmem_ulonglong_atomic_fetch_add_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z34nvshmem_ulonglong_atomic_fetch_add_nbst_caller(arg_0, arg_1, arg_2):
        return _Z34nvshmem_ulonglong_atomic_fetch_add_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulonglong_atomic_fetch_add, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmem_ulonglong_atomic_fetch_add_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmem_ulonglong_atomic_fetch_add_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmem_ulonglong_atomic_fetch_add_nbst(shim_stream, shim_obj)


def int32_atomic_fetch_add():
    pass
    

def _lower__Z30nvshmem_int32_atomic_fetch_add_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_int32_atomic_fetch_add_nbst(int32_t &retval , int32_t ** target, int32_t* value, int* pe) {
        retval = nvshmem_int32_atomic_fetch_add(*target, *value, *pe);
        return 0;
    }
        """


    _Z30nvshmem_int32_atomic_fetch_add_nbst = declare_device(
        '_Z30nvshmem_int32_atomic_fetch_add_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmem_int32_atomic_fetch_add_nbst_caller(arg_0, arg_1, arg_2):
        return _Z30nvshmem_int32_atomic_fetch_add_nbst(arg_0, arg_1, arg_2)
    

    @lower(int32_atomic_fetch_add, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmem_int32_atomic_fetch_add_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_int32_atomic_fetch_add_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmem_int32_atomic_fetch_add_nbst(shim_stream, shim_obj)


def uint32_atomic_fetch_add():
    pass
    

def _lower__Z31nvshmem_uint32_atomic_fetch_add_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmem_uint32_atomic_fetch_add_nbst(uint32_t &retval , uint32_t ** target, uint32_t* value, int* pe) {
        retval = nvshmem_uint32_atomic_fetch_add(*target, *value, *pe);
        return 0;
    }
        """


    _Z31nvshmem_uint32_atomic_fetch_add_nbst = declare_device(
        '_Z31nvshmem_uint32_atomic_fetch_add_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z31nvshmem_uint32_atomic_fetch_add_nbst_caller(arg_0, arg_1, arg_2):
        return _Z31nvshmem_uint32_atomic_fetch_add_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint32_atomic_fetch_add, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmem_uint32_atomic_fetch_add_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmem_uint32_atomic_fetch_add_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmem_uint32_atomic_fetch_add_nbst(shim_stream, shim_obj)


def uint64_atomic_fetch_add():
    pass
    

def _lower__Z31nvshmem_uint64_atomic_fetch_add_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmem_uint64_atomic_fetch_add_nbst(uint64_t &retval , uint64_t ** target, uint64_t* value, int* pe) {
        retval = nvshmem_uint64_atomic_fetch_add(*target, *value, *pe);
        return 0;
    }
        """


    _Z31nvshmem_uint64_atomic_fetch_add_nbst = declare_device(
        '_Z31nvshmem_uint64_atomic_fetch_add_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z31nvshmem_uint64_atomic_fetch_add_nbst_caller(arg_0, arg_1, arg_2):
        return _Z31nvshmem_uint64_atomic_fetch_add_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint64_atomic_fetch_add, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmem_uint64_atomic_fetch_add_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmem_uint64_atomic_fetch_add_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmem_uint64_atomic_fetch_add_nbst(shim_stream, shim_obj)


def size_atomic_fetch_add():
    pass
    

def _lower__Z29nvshmem_size_atomic_fetch_add_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_size_atomic_fetch_add_nbst(unsigned long &retval , unsigned long ** target, unsigned long* value, int* pe) {
        retval = nvshmem_size_atomic_fetch_add(*target, *value, *pe);
        return 0;
    }
        """


    _Z29nvshmem_size_atomic_fetch_add_nbst = declare_device(
        '_Z29nvshmem_size_atomic_fetch_add_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z29nvshmem_size_atomic_fetch_add_nbst_caller(arg_0, arg_1, arg_2):
        return _Z29nvshmem_size_atomic_fetch_add_nbst(arg_0, arg_1, arg_2)
    

    @lower(size_atomic_fetch_add, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmem_size_atomic_fetch_add_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_size_atomic_fetch_add_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmem_size_atomic_fetch_add_nbst(shim_stream, shim_obj)


def int_atomic_add():
    pass
    

def _lower__Z22nvshmem_int_atomic_add_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_int_atomic_add_nbst(int &retval , int ** target, int* value, int* pe) {
        nvshmem_int_atomic_add(*target, *value, *pe);
        return 0;
    }
        """


    _Z22nvshmem_int_atomic_add_nbst = declare_device(
        '_Z22nvshmem_int_atomic_add_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_int_atomic_add_nbst_caller(arg_0, arg_1, arg_2):
        return _Z22nvshmem_int_atomic_add_nbst(arg_0, arg_1, arg_2)
    

    @lower(int_atomic_add, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmem_int_atomic_add_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_int_atomic_add_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_int_atomic_add_nbst(shim_stream, shim_obj)


def long_atomic_add():
    pass
    

def _lower__Z23nvshmem_long_atomic_add_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_long_atomic_add_nbst(int &retval , long ** target, long* value, int* pe) {
        nvshmem_long_atomic_add(*target, *value, *pe);
        return 0;
    }
        """


    _Z23nvshmem_long_atomic_add_nbst = declare_device(
        '_Z23nvshmem_long_atomic_add_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_long_atomic_add_nbst_caller(arg_0, arg_1, arg_2):
        return _Z23nvshmem_long_atomic_add_nbst(arg_0, arg_1, arg_2)
    

    @lower(long_atomic_add, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_long_atomic_add_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_long_atomic_add_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_long_atomic_add_nbst(shim_stream, shim_obj)


def uint_atomic_add():
    pass
    

def _lower__Z23nvshmem_uint_atomic_add_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_uint_atomic_add_nbst(int &retval , unsigned int ** target, unsigned int* value, int* pe) {
        nvshmem_uint_atomic_add(*target, *value, *pe);
        return 0;
    }
        """


    _Z23nvshmem_uint_atomic_add_nbst = declare_device(
        '_Z23nvshmem_uint_atomic_add_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_uint_atomic_add_nbst_caller(arg_0, arg_1, arg_2):
        return _Z23nvshmem_uint_atomic_add_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint_atomic_add, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_uint_atomic_add_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_uint_atomic_add_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_uint_atomic_add_nbst(shim_stream, shim_obj)


def ulong_atomic_add():
    pass
    

def _lower__Z24nvshmem_ulong_atomic_add_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_ulong_atomic_add_nbst(int &retval , unsigned long ** target, unsigned long* value, int* pe) {
        nvshmem_ulong_atomic_add(*target, *value, *pe);
        return 0;
    }
        """


    _Z24nvshmem_ulong_atomic_add_nbst = declare_device(
        '_Z24nvshmem_ulong_atomic_add_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_ulong_atomic_add_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_ulong_atomic_add_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulong_atomic_add, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_ulong_atomic_add_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_ulong_atomic_add_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_ulong_atomic_add_nbst(shim_stream, shim_obj)


def ulonglong_atomic_add():
    pass
    

def _lower__Z28nvshmem_ulonglong_atomic_add_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_ulonglong_atomic_add_nbst(int &retval , unsigned long long ** target, unsigned long long* value, int* pe) {
        nvshmem_ulonglong_atomic_add(*target, *value, *pe);
        return 0;
    }
        """


    _Z28nvshmem_ulonglong_atomic_add_nbst = declare_device(
        '_Z28nvshmem_ulonglong_atomic_add_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_ulonglong_atomic_add_nbst_caller(arg_0, arg_1, arg_2):
        return _Z28nvshmem_ulonglong_atomic_add_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulonglong_atomic_add, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_ulonglong_atomic_add_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_ulonglong_atomic_add_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_ulonglong_atomic_add_nbst(shim_stream, shim_obj)


def int32_atomic_add():
    pass
    

def _lower__Z24nvshmem_int32_atomic_add_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_int32_atomic_add_nbst(int &retval , int32_t ** target, int32_t* value, int* pe) {
        nvshmem_int32_atomic_add(*target, *value, *pe);
        return 0;
    }
        """


    _Z24nvshmem_int32_atomic_add_nbst = declare_device(
        '_Z24nvshmem_int32_atomic_add_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_int32_atomic_add_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_int32_atomic_add_nbst(arg_0, arg_1, arg_2)
    

    @lower(int32_atomic_add, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_int32_atomic_add_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_int32_atomic_add_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_int32_atomic_add_nbst(shim_stream, shim_obj)


def uint32_atomic_add():
    pass
    

def _lower__Z25nvshmem_uint32_atomic_add_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_uint32_atomic_add_nbst(int &retval , uint32_t ** target, uint32_t* value, int* pe) {
        nvshmem_uint32_atomic_add(*target, *value, *pe);
        return 0;
    }
        """


    _Z25nvshmem_uint32_atomic_add_nbst = declare_device(
        '_Z25nvshmem_uint32_atomic_add_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_uint32_atomic_add_nbst_caller(arg_0, arg_1, arg_2):
        return _Z25nvshmem_uint32_atomic_add_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint32_atomic_add, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_uint32_atomic_add_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_uint32_atomic_add_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_uint32_atomic_add_nbst(shim_stream, shim_obj)


def uint64_atomic_add():
    pass
    

def _lower__Z25nvshmem_uint64_atomic_add_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_uint64_atomic_add_nbst(int &retval , uint64_t ** target, uint64_t* value, int* pe) {
        nvshmem_uint64_atomic_add(*target, *value, *pe);
        return 0;
    }
        """


    _Z25nvshmem_uint64_atomic_add_nbst = declare_device(
        '_Z25nvshmem_uint64_atomic_add_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_uint64_atomic_add_nbst_caller(arg_0, arg_1, arg_2):
        return _Z25nvshmem_uint64_atomic_add_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint64_atomic_add, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_uint64_atomic_add_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_uint64_atomic_add_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_uint64_atomic_add_nbst(shim_stream, shim_obj)


def size_atomic_add():
    pass
    

def _lower__Z23nvshmem_size_atomic_add_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_size_atomic_add_nbst(int &retval , unsigned long ** target, unsigned long* value, int* pe) {
        nvshmem_size_atomic_add(*target, *value, *pe);
        return 0;
    }
        """


    _Z23nvshmem_size_atomic_add_nbst = declare_device(
        '_Z23nvshmem_size_atomic_add_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_size_atomic_add_nbst_caller(arg_0, arg_1, arg_2):
        return _Z23nvshmem_size_atomic_add_nbst(arg_0, arg_1, arg_2)
    

    @lower(size_atomic_add, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_size_atomic_add_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_size_atomic_add_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_size_atomic_add_nbst(shim_stream, shim_obj)


def int_atomic_fetch_inc():
    pass
    

def _lower__Z28nvshmem_int_atomic_fetch_inc_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_int_atomic_fetch_inc_nbst(int &retval , int ** target, int* pe) {
        retval = nvshmem_int_atomic_fetch_inc(*target, *pe);
        return 0;
    }
        """


    _Z28nvshmem_int_atomic_fetch_inc_nbst = declare_device(
        '_Z28nvshmem_int_atomic_fetch_inc_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_int_atomic_fetch_inc_nbst_caller(arg_0, arg_1):
        return _Z28nvshmem_int_atomic_fetch_inc_nbst(arg_0, arg_1)
    

    @lower(int_atomic_fetch_inc, CPointer(int32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_int_atomic_fetch_inc_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_int_atomic_fetch_inc_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_int_atomic_fetch_inc_nbst(shim_stream, shim_obj)


def long_atomic_fetch_inc():
    pass
    

def _lower__Z29nvshmem_long_atomic_fetch_inc_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_long_atomic_fetch_inc_nbst(long &retval , long ** target, int* pe) {
        retval = nvshmem_long_atomic_fetch_inc(*target, *pe);
        return 0;
    }
        """


    _Z29nvshmem_long_atomic_fetch_inc_nbst = declare_device(
        '_Z29nvshmem_long_atomic_fetch_inc_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int32)
        )
    )
    

    def _Z29nvshmem_long_atomic_fetch_inc_nbst_caller(arg_0, arg_1):
        return _Z29nvshmem_long_atomic_fetch_inc_nbst(arg_0, arg_1)
    

    @lower(long_atomic_fetch_inc, CPointer(int64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmem_long_atomic_fetch_inc_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_long_atomic_fetch_inc_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmem_long_atomic_fetch_inc_nbst(shim_stream, shim_obj)


def uint_atomic_fetch_inc():
    pass
    

def _lower__Z29nvshmem_uint_atomic_fetch_inc_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_uint_atomic_fetch_inc_nbst(unsigned int &retval , unsigned int ** target, int* pe) {
        retval = nvshmem_uint_atomic_fetch_inc(*target, *pe);
        return 0;
    }
        """


    _Z29nvshmem_uint_atomic_fetch_inc_nbst = declare_device(
        '_Z29nvshmem_uint_atomic_fetch_inc_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(int32)
        )
    )
    

    def _Z29nvshmem_uint_atomic_fetch_inc_nbst_caller(arg_0, arg_1):
        return _Z29nvshmem_uint_atomic_fetch_inc_nbst(arg_0, arg_1)
    

    @lower(uint_atomic_fetch_inc, CPointer(uint32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmem_uint_atomic_fetch_inc_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_uint_atomic_fetch_inc_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmem_uint_atomic_fetch_inc_nbst(shim_stream, shim_obj)


def ulong_atomic_fetch_inc():
    pass
    

def _lower__Z30nvshmem_ulong_atomic_fetch_inc_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_ulong_atomic_fetch_inc_nbst(unsigned long &retval , unsigned long ** target, int* pe) {
        retval = nvshmem_ulong_atomic_fetch_inc(*target, *pe);
        return 0;
    }
        """


    _Z30nvshmem_ulong_atomic_fetch_inc_nbst = declare_device(
        '_Z30nvshmem_ulong_atomic_fetch_inc_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(int32)
        )
    )
    

    def _Z30nvshmem_ulong_atomic_fetch_inc_nbst_caller(arg_0, arg_1):
        return _Z30nvshmem_ulong_atomic_fetch_inc_nbst(arg_0, arg_1)
    

    @lower(ulong_atomic_fetch_inc, CPointer(uint64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmem_ulong_atomic_fetch_inc_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_ulong_atomic_fetch_inc_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmem_ulong_atomic_fetch_inc_nbst(shim_stream, shim_obj)


def ulonglong_atomic_fetch_inc():
    pass
    

def _lower__Z34nvshmem_ulonglong_atomic_fetch_inc_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmem_ulonglong_atomic_fetch_inc_nbst(unsigned long long &retval , unsigned long long ** target, int* pe) {
        retval = nvshmem_ulonglong_atomic_fetch_inc(*target, *pe);
        return 0;
    }
        """


    _Z34nvshmem_ulonglong_atomic_fetch_inc_nbst = declare_device(
        '_Z34nvshmem_ulonglong_atomic_fetch_inc_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(int32)
        )
    )
    

    def _Z34nvshmem_ulonglong_atomic_fetch_inc_nbst_caller(arg_0, arg_1):
        return _Z34nvshmem_ulonglong_atomic_fetch_inc_nbst(arg_0, arg_1)
    

    @lower(ulonglong_atomic_fetch_inc, CPointer(uint64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmem_ulonglong_atomic_fetch_inc_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmem_ulonglong_atomic_fetch_inc_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmem_ulonglong_atomic_fetch_inc_nbst(shim_stream, shim_obj)


def int32_atomic_fetch_inc():
    pass
    

def _lower__Z30nvshmem_int32_atomic_fetch_inc_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_int32_atomic_fetch_inc_nbst(int32_t &retval , int32_t ** target, int* pe) {
        retval = nvshmem_int32_atomic_fetch_inc(*target, *pe);
        return 0;
    }
        """


    _Z30nvshmem_int32_atomic_fetch_inc_nbst = declare_device(
        '_Z30nvshmem_int32_atomic_fetch_inc_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(int32)
        )
    )
    

    def _Z30nvshmem_int32_atomic_fetch_inc_nbst_caller(arg_0, arg_1):
        return _Z30nvshmem_int32_atomic_fetch_inc_nbst(arg_0, arg_1)
    

    @lower(int32_atomic_fetch_inc, CPointer(int32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmem_int32_atomic_fetch_inc_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_int32_atomic_fetch_inc_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmem_int32_atomic_fetch_inc_nbst(shim_stream, shim_obj)


def uint32_atomic_fetch_inc():
    pass
    

def _lower__Z31nvshmem_uint32_atomic_fetch_inc_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmem_uint32_atomic_fetch_inc_nbst(uint32_t &retval , uint32_t ** target, int* pe) {
        retval = nvshmem_uint32_atomic_fetch_inc(*target, *pe);
        return 0;
    }
        """


    _Z31nvshmem_uint32_atomic_fetch_inc_nbst = declare_device(
        '_Z31nvshmem_uint32_atomic_fetch_inc_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(int32)
        )
    )
    

    def _Z31nvshmem_uint32_atomic_fetch_inc_nbst_caller(arg_0, arg_1):
        return _Z31nvshmem_uint32_atomic_fetch_inc_nbst(arg_0, arg_1)
    

    @lower(uint32_atomic_fetch_inc, CPointer(uint32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmem_uint32_atomic_fetch_inc_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmem_uint32_atomic_fetch_inc_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmem_uint32_atomic_fetch_inc_nbst(shim_stream, shim_obj)


def uint64_atomic_fetch_inc():
    pass
    

def _lower__Z31nvshmem_uint64_atomic_fetch_inc_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmem_uint64_atomic_fetch_inc_nbst(uint64_t &retval , uint64_t ** target, int* pe) {
        retval = nvshmem_uint64_atomic_fetch_inc(*target, *pe);
        return 0;
    }
        """


    _Z31nvshmem_uint64_atomic_fetch_inc_nbst = declare_device(
        '_Z31nvshmem_uint64_atomic_fetch_inc_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(int32)
        )
    )
    

    def _Z31nvshmem_uint64_atomic_fetch_inc_nbst_caller(arg_0, arg_1):
        return _Z31nvshmem_uint64_atomic_fetch_inc_nbst(arg_0, arg_1)
    

    @lower(uint64_atomic_fetch_inc, CPointer(uint64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmem_uint64_atomic_fetch_inc_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmem_uint64_atomic_fetch_inc_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmem_uint64_atomic_fetch_inc_nbst(shim_stream, shim_obj)


def size_atomic_fetch_inc():
    pass
    

def _lower__Z29nvshmem_size_atomic_fetch_inc_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_size_atomic_fetch_inc_nbst(unsigned long &retval , unsigned long ** target, int* pe) {
        retval = nvshmem_size_atomic_fetch_inc(*target, *pe);
        return 0;
    }
        """


    _Z29nvshmem_size_atomic_fetch_inc_nbst = declare_device(
        '_Z29nvshmem_size_atomic_fetch_inc_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(int32)
        )
    )
    

    def _Z29nvshmem_size_atomic_fetch_inc_nbst_caller(arg_0, arg_1):
        return _Z29nvshmem_size_atomic_fetch_inc_nbst(arg_0, arg_1)
    

    @lower(size_atomic_fetch_inc, CPointer(uint64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmem_size_atomic_fetch_inc_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_size_atomic_fetch_inc_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmem_size_atomic_fetch_inc_nbst(shim_stream, shim_obj)


def int_atomic_inc():
    pass
    

def _lower__Z22nvshmem_int_atomic_inc_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_int_atomic_inc_nbst(int &retval , int ** target, int* pe) {
        nvshmem_int_atomic_inc(*target, *pe);
        return 0;
    }
        """


    _Z22nvshmem_int_atomic_inc_nbst = declare_device(
        '_Z22nvshmem_int_atomic_inc_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_int_atomic_inc_nbst_caller(arg_0, arg_1):
        return _Z22nvshmem_int_atomic_inc_nbst(arg_0, arg_1)
    

    @lower(int_atomic_inc, CPointer(int32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmem_int_atomic_inc_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_int_atomic_inc_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_int_atomic_inc_nbst(shim_stream, shim_obj)


def long_atomic_inc():
    pass
    

def _lower__Z23nvshmem_long_atomic_inc_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_long_atomic_inc_nbst(int &retval , long ** target, int* pe) {
        nvshmem_long_atomic_inc(*target, *pe);
        return 0;
    }
        """


    _Z23nvshmem_long_atomic_inc_nbst = declare_device(
        '_Z23nvshmem_long_atomic_inc_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_long_atomic_inc_nbst_caller(arg_0, arg_1):
        return _Z23nvshmem_long_atomic_inc_nbst(arg_0, arg_1)
    

    @lower(long_atomic_inc, CPointer(int64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_long_atomic_inc_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_long_atomic_inc_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_long_atomic_inc_nbst(shim_stream, shim_obj)


def uint_atomic_inc():
    pass
    

def _lower__Z23nvshmem_uint_atomic_inc_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_uint_atomic_inc_nbst(int &retval , unsigned int ** target, int* pe) {
        nvshmem_uint_atomic_inc(*target, *pe);
        return 0;
    }
        """


    _Z23nvshmem_uint_atomic_inc_nbst = declare_device(
        '_Z23nvshmem_uint_atomic_inc_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_uint_atomic_inc_nbst_caller(arg_0, arg_1):
        return _Z23nvshmem_uint_atomic_inc_nbst(arg_0, arg_1)
    

    @lower(uint_atomic_inc, CPointer(uint32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_uint_atomic_inc_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_uint_atomic_inc_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_uint_atomic_inc_nbst(shim_stream, shim_obj)


def ulong_atomic_inc():
    pass
    

def _lower__Z24nvshmem_ulong_atomic_inc_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_ulong_atomic_inc_nbst(int &retval , unsigned long ** target, int* pe) {
        nvshmem_ulong_atomic_inc(*target, *pe);
        return 0;
    }
        """


    _Z24nvshmem_ulong_atomic_inc_nbst = declare_device(
        '_Z24nvshmem_ulong_atomic_inc_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_ulong_atomic_inc_nbst_caller(arg_0, arg_1):
        return _Z24nvshmem_ulong_atomic_inc_nbst(arg_0, arg_1)
    

    @lower(ulong_atomic_inc, CPointer(uint64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_ulong_atomic_inc_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_ulong_atomic_inc_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_ulong_atomic_inc_nbst(shim_stream, shim_obj)


def ulonglong_atomic_inc():
    pass
    

def _lower__Z28nvshmem_ulonglong_atomic_inc_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_ulonglong_atomic_inc_nbst(int &retval , unsigned long long ** target, int* pe) {
        nvshmem_ulonglong_atomic_inc(*target, *pe);
        return 0;
    }
        """


    _Z28nvshmem_ulonglong_atomic_inc_nbst = declare_device(
        '_Z28nvshmem_ulonglong_atomic_inc_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_ulonglong_atomic_inc_nbst_caller(arg_0, arg_1):
        return _Z28nvshmem_ulonglong_atomic_inc_nbst(arg_0, arg_1)
    

    @lower(ulonglong_atomic_inc, CPointer(uint64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_ulonglong_atomic_inc_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_ulonglong_atomic_inc_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_ulonglong_atomic_inc_nbst(shim_stream, shim_obj)


def int32_atomic_inc():
    pass
    

def _lower__Z24nvshmem_int32_atomic_inc_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_int32_atomic_inc_nbst(int &retval , int32_t ** target, int* pe) {
        nvshmem_int32_atomic_inc(*target, *pe);
        return 0;
    }
        """


    _Z24nvshmem_int32_atomic_inc_nbst = declare_device(
        '_Z24nvshmem_int32_atomic_inc_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_int32_atomic_inc_nbst_caller(arg_0, arg_1):
        return _Z24nvshmem_int32_atomic_inc_nbst(arg_0, arg_1)
    

    @lower(int32_atomic_inc, CPointer(int32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_int32_atomic_inc_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_int32_atomic_inc_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_int32_atomic_inc_nbst(shim_stream, shim_obj)


def uint32_atomic_inc():
    pass
    

def _lower__Z25nvshmem_uint32_atomic_inc_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_uint32_atomic_inc_nbst(int &retval , uint32_t ** target, int* pe) {
        nvshmem_uint32_atomic_inc(*target, *pe);
        return 0;
    }
        """


    _Z25nvshmem_uint32_atomic_inc_nbst = declare_device(
        '_Z25nvshmem_uint32_atomic_inc_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_uint32_atomic_inc_nbst_caller(arg_0, arg_1):
        return _Z25nvshmem_uint32_atomic_inc_nbst(arg_0, arg_1)
    

    @lower(uint32_atomic_inc, CPointer(uint32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_uint32_atomic_inc_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_uint32_atomic_inc_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_uint32_atomic_inc_nbst(shim_stream, shim_obj)


def uint64_atomic_inc():
    pass
    

def _lower__Z25nvshmem_uint64_atomic_inc_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_uint64_atomic_inc_nbst(int &retval , uint64_t ** target, int* pe) {
        nvshmem_uint64_atomic_inc(*target, *pe);
        return 0;
    }
        """


    _Z25nvshmem_uint64_atomic_inc_nbst = declare_device(
        '_Z25nvshmem_uint64_atomic_inc_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_uint64_atomic_inc_nbst_caller(arg_0, arg_1):
        return _Z25nvshmem_uint64_atomic_inc_nbst(arg_0, arg_1)
    

    @lower(uint64_atomic_inc, CPointer(uint64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_uint64_atomic_inc_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_uint64_atomic_inc_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_uint64_atomic_inc_nbst(shim_stream, shim_obj)


def size_atomic_inc():
    pass
    

def _lower__Z23nvshmem_size_atomic_inc_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_size_atomic_inc_nbst(int &retval , unsigned long ** target, int* pe) {
        nvshmem_size_atomic_inc(*target, *pe);
        return 0;
    }
        """


    _Z23nvshmem_size_atomic_inc_nbst = declare_device(
        '_Z23nvshmem_size_atomic_inc_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_size_atomic_inc_nbst_caller(arg_0, arg_1):
        return _Z23nvshmem_size_atomic_inc_nbst(arg_0, arg_1)
    

    @lower(size_atomic_inc, CPointer(uint64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_size_atomic_inc_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_size_atomic_inc_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_size_atomic_inc_nbst(shim_stream, shim_obj)


def int_atomic_compare_swap():
    pass
    

def _lower__Z31nvshmem_int_atomic_compare_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmem_int_atomic_compare_swap_nbst(int &retval , int ** target, int* compare, int* value, int* pe) {
        retval = nvshmem_int_atomic_compare_swap(*target, *compare, *value, *pe);
        return 0;
    }
        """


    _Z31nvshmem_int_atomic_compare_swap_nbst = declare_device(
        '_Z31nvshmem_int_atomic_compare_swap_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmem_int_atomic_compare_swap_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z31nvshmem_int_atomic_compare_swap_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_atomic_compare_swap, CPointer(int32), int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmem_int_atomic_compare_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmem_int_atomic_compare_swap_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmem_int_atomic_compare_swap_nbst(shim_stream, shim_obj)


def long_atomic_compare_swap():
    pass
    

def _lower__Z32nvshmem_long_atomic_compare_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmem_long_atomic_compare_swap_nbst(long &retval , long ** target, long* compare, long* value, int* pe) {
        retval = nvshmem_long_atomic_compare_swap(*target, *compare, *value, *pe);
        return 0;
    }
        """


    _Z32nvshmem_long_atomic_compare_swap_nbst = declare_device(
        '_Z32nvshmem_long_atomic_compare_swap_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z32nvshmem_long_atomic_compare_swap_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z32nvshmem_long_atomic_compare_swap_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_atomic_compare_swap, CPointer(int64), int64, int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmem_long_atomic_compare_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmem_long_atomic_compare_swap_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmem_long_atomic_compare_swap_nbst(shim_stream, shim_obj)


def longlong_atomic_compare_swap():
    pass
    

def _lower__Z36nvshmem_longlong_atomic_compare_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmem_longlong_atomic_compare_swap_nbst(long long &retval , long long ** target, long long* compare, long long* value, int* pe) {
        retval = nvshmem_longlong_atomic_compare_swap(*target, *compare, *value, *pe);
        return 0;
    }
        """


    _Z36nvshmem_longlong_atomic_compare_swap_nbst = declare_device(
        '_Z36nvshmem_longlong_atomic_compare_swap_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z36nvshmem_longlong_atomic_compare_swap_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z36nvshmem_longlong_atomic_compare_swap_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_atomic_compare_swap, CPointer(int64), int64, int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z36nvshmem_longlong_atomic_compare_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmem_longlong_atomic_compare_swap_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z36nvshmem_longlong_atomic_compare_swap_nbst(shim_stream, shim_obj)


def uint_atomic_compare_swap():
    pass
    

def _lower__Z32nvshmem_uint_atomic_compare_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmem_uint_atomic_compare_swap_nbst(unsigned int &retval , unsigned int ** target, unsigned int* compare, unsigned int* value, int* pe) {
        retval = nvshmem_uint_atomic_compare_swap(*target, *compare, *value, *pe);
        return 0;
    }
        """


    _Z32nvshmem_uint_atomic_compare_swap_nbst = declare_device(
        '_Z32nvshmem_uint_atomic_compare_swap_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z32nvshmem_uint_atomic_compare_swap_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z32nvshmem_uint_atomic_compare_swap_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_atomic_compare_swap, CPointer(uint32), uint32, uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmem_uint_atomic_compare_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmem_uint_atomic_compare_swap_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmem_uint_atomic_compare_swap_nbst(shim_stream, shim_obj)


def ulong_atomic_compare_swap():
    pass
    

def _lower__Z33nvshmem_ulong_atomic_compare_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmem_ulong_atomic_compare_swap_nbst(unsigned long &retval , unsigned long ** target, unsigned long* compare, unsigned long* value, int* pe) {
        retval = nvshmem_ulong_atomic_compare_swap(*target, *compare, *value, *pe);
        return 0;
    }
        """


    _Z33nvshmem_ulong_atomic_compare_swap_nbst = declare_device(
        '_Z33nvshmem_ulong_atomic_compare_swap_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z33nvshmem_ulong_atomic_compare_swap_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z33nvshmem_ulong_atomic_compare_swap_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_atomic_compare_swap, CPointer(uint64), uint64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmem_ulong_atomic_compare_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmem_ulong_atomic_compare_swap_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmem_ulong_atomic_compare_swap_nbst(shim_stream, shim_obj)


def ulonglong_atomic_compare_swap():
    pass
    

def _lower__Z37nvshmem_ulonglong_atomic_compare_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmem_ulonglong_atomic_compare_swap_nbst(unsigned long long &retval , unsigned long long ** target, unsigned long long* compare, unsigned long long* value, int* pe) {
        retval = nvshmem_ulonglong_atomic_compare_swap(*target, *compare, *value, *pe);
        return 0;
    }
        """


    _Z37nvshmem_ulonglong_atomic_compare_swap_nbst = declare_device(
        '_Z37nvshmem_ulonglong_atomic_compare_swap_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z37nvshmem_ulonglong_atomic_compare_swap_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z37nvshmem_ulonglong_atomic_compare_swap_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_atomic_compare_swap, CPointer(uint64), uint64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmem_ulonglong_atomic_compare_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmem_ulonglong_atomic_compare_swap_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmem_ulonglong_atomic_compare_swap_nbst(shim_stream, shim_obj)


def int32_atomic_compare_swap():
    pass
    

def _lower__Z33nvshmem_int32_atomic_compare_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmem_int32_atomic_compare_swap_nbst(int32_t &retval , int32_t ** target, int32_t* compare, int32_t* value, int* pe) {
        retval = nvshmem_int32_atomic_compare_swap(*target, *compare, *value, *pe);
        return 0;
    }
        """


    _Z33nvshmem_int32_atomic_compare_swap_nbst = declare_device(
        '_Z33nvshmem_int32_atomic_compare_swap_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmem_int32_atomic_compare_swap_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z33nvshmem_int32_atomic_compare_swap_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_atomic_compare_swap, CPointer(int32), int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmem_int32_atomic_compare_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmem_int32_atomic_compare_swap_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmem_int32_atomic_compare_swap_nbst(shim_stream, shim_obj)


def int64_atomic_compare_swap():
    pass
    

def _lower__Z33nvshmem_int64_atomic_compare_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmem_int64_atomic_compare_swap_nbst(int64_t &retval , int64_t ** target, int64_t* compare, int64_t* value, int* pe) {
        retval = nvshmem_int64_atomic_compare_swap(*target, *compare, *value, *pe);
        return 0;
    }
        """


    _Z33nvshmem_int64_atomic_compare_swap_nbst = declare_device(
        '_Z33nvshmem_int64_atomic_compare_swap_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z33nvshmem_int64_atomic_compare_swap_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z33nvshmem_int64_atomic_compare_swap_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_atomic_compare_swap, CPointer(int64), int64, int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmem_int64_atomic_compare_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmem_int64_atomic_compare_swap_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmem_int64_atomic_compare_swap_nbst(shim_stream, shim_obj)


def uint32_atomic_compare_swap():
    pass
    

def _lower__Z34nvshmem_uint32_atomic_compare_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmem_uint32_atomic_compare_swap_nbst(uint32_t &retval , uint32_t ** target, uint32_t* compare, uint32_t* value, int* pe) {
        retval = nvshmem_uint32_atomic_compare_swap(*target, *compare, *value, *pe);
        return 0;
    }
        """


    _Z34nvshmem_uint32_atomic_compare_swap_nbst = declare_device(
        '_Z34nvshmem_uint32_atomic_compare_swap_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z34nvshmem_uint32_atomic_compare_swap_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z34nvshmem_uint32_atomic_compare_swap_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_atomic_compare_swap, CPointer(uint32), uint32, uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmem_uint32_atomic_compare_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmem_uint32_atomic_compare_swap_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmem_uint32_atomic_compare_swap_nbst(shim_stream, shim_obj)


def uint64_atomic_compare_swap():
    pass
    

def _lower__Z34nvshmem_uint64_atomic_compare_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmem_uint64_atomic_compare_swap_nbst(uint64_t &retval , uint64_t ** target, uint64_t* compare, uint64_t* value, int* pe) {
        retval = nvshmem_uint64_atomic_compare_swap(*target, *compare, *value, *pe);
        return 0;
    }
        """


    _Z34nvshmem_uint64_atomic_compare_swap_nbst = declare_device(
        '_Z34nvshmem_uint64_atomic_compare_swap_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z34nvshmem_uint64_atomic_compare_swap_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z34nvshmem_uint64_atomic_compare_swap_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_atomic_compare_swap, CPointer(uint64), uint64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmem_uint64_atomic_compare_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmem_uint64_atomic_compare_swap_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmem_uint64_atomic_compare_swap_nbst(shim_stream, shim_obj)


def size_atomic_compare_swap():
    pass
    

def _lower__Z32nvshmem_size_atomic_compare_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmem_size_atomic_compare_swap_nbst(unsigned long &retval , unsigned long ** target, unsigned long* compare, unsigned long* value, int* pe) {
        retval = nvshmem_size_atomic_compare_swap(*target, *compare, *value, *pe);
        return 0;
    }
        """


    _Z32nvshmem_size_atomic_compare_swap_nbst = declare_device(
        '_Z32nvshmem_size_atomic_compare_swap_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z32nvshmem_size_atomic_compare_swap_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z32nvshmem_size_atomic_compare_swap_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_atomic_compare_swap, CPointer(uint64), uint64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmem_size_atomic_compare_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmem_size_atomic_compare_swap_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmem_size_atomic_compare_swap_nbst(shim_stream, shim_obj)


def ptrdiff_atomic_compare_swap():
    pass
    

def _lower__Z35nvshmem_ptrdiff_atomic_compare_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmem_ptrdiff_atomic_compare_swap_nbst(long &retval , long ** target, long* compare, long* value, int* pe) {
        retval = nvshmem_ptrdiff_atomic_compare_swap(*target, *compare, *value, *pe);
        return 0;
    }
        """


    _Z35nvshmem_ptrdiff_atomic_compare_swap_nbst = declare_device(
        '_Z35nvshmem_ptrdiff_atomic_compare_swap_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z35nvshmem_ptrdiff_atomic_compare_swap_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z35nvshmem_ptrdiff_atomic_compare_swap_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ptrdiff_atomic_compare_swap, CPointer(int64), int64, int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmem_ptrdiff_atomic_compare_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmem_ptrdiff_atomic_compare_swap_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmem_ptrdiff_atomic_compare_swap_nbst(shim_stream, shim_obj)


def uint_atomic_fetch_and():
    pass
    

def _lower__Z29nvshmem_uint_atomic_fetch_and_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_uint_atomic_fetch_and_nbst(unsigned int &retval , unsigned int ** target, unsigned int* value, int* pe) {
        retval = nvshmem_uint_atomic_fetch_and(*target, *value, *pe);
        return 0;
    }
        """


    _Z29nvshmem_uint_atomic_fetch_and_nbst = declare_device(
        '_Z29nvshmem_uint_atomic_fetch_and_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z29nvshmem_uint_atomic_fetch_and_nbst_caller(arg_0, arg_1, arg_2):
        return _Z29nvshmem_uint_atomic_fetch_and_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint_atomic_fetch_and, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmem_uint_atomic_fetch_and_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_uint_atomic_fetch_and_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmem_uint_atomic_fetch_and_nbst(shim_stream, shim_obj)


def ulong_atomic_fetch_and():
    pass
    

def _lower__Z30nvshmem_ulong_atomic_fetch_and_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_ulong_atomic_fetch_and_nbst(unsigned long &retval , unsigned long ** target, unsigned long* value, int* pe) {
        retval = nvshmem_ulong_atomic_fetch_and(*target, *value, *pe);
        return 0;
    }
        """


    _Z30nvshmem_ulong_atomic_fetch_and_nbst = declare_device(
        '_Z30nvshmem_ulong_atomic_fetch_and_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z30nvshmem_ulong_atomic_fetch_and_nbst_caller(arg_0, arg_1, arg_2):
        return _Z30nvshmem_ulong_atomic_fetch_and_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulong_atomic_fetch_and, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmem_ulong_atomic_fetch_and_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_ulong_atomic_fetch_and_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmem_ulong_atomic_fetch_and_nbst(shim_stream, shim_obj)


def ulonglong_atomic_fetch_and():
    pass
    

def _lower__Z34nvshmem_ulonglong_atomic_fetch_and_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmem_ulonglong_atomic_fetch_and_nbst(unsigned long long &retval , unsigned long long ** target, unsigned long long* value, int* pe) {
        retval = nvshmem_ulonglong_atomic_fetch_and(*target, *value, *pe);
        return 0;
    }
        """


    _Z34nvshmem_ulonglong_atomic_fetch_and_nbst = declare_device(
        '_Z34nvshmem_ulonglong_atomic_fetch_and_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z34nvshmem_ulonglong_atomic_fetch_and_nbst_caller(arg_0, arg_1, arg_2):
        return _Z34nvshmem_ulonglong_atomic_fetch_and_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulonglong_atomic_fetch_and, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmem_ulonglong_atomic_fetch_and_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmem_ulonglong_atomic_fetch_and_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmem_ulonglong_atomic_fetch_and_nbst(shim_stream, shim_obj)


def int32_atomic_fetch_and():
    pass
    

def _lower__Z30nvshmem_int32_atomic_fetch_and_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_int32_atomic_fetch_and_nbst(int32_t &retval , int32_t ** target, int32_t* value, int* pe) {
        retval = nvshmem_int32_atomic_fetch_and(*target, *value, *pe);
        return 0;
    }
        """


    _Z30nvshmem_int32_atomic_fetch_and_nbst = declare_device(
        '_Z30nvshmem_int32_atomic_fetch_and_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmem_int32_atomic_fetch_and_nbst_caller(arg_0, arg_1, arg_2):
        return _Z30nvshmem_int32_atomic_fetch_and_nbst(arg_0, arg_1, arg_2)
    

    @lower(int32_atomic_fetch_and, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmem_int32_atomic_fetch_and_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_int32_atomic_fetch_and_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmem_int32_atomic_fetch_and_nbst(shim_stream, shim_obj)


def int64_atomic_fetch_and():
    pass
    

def _lower__Z30nvshmem_int64_atomic_fetch_and_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_int64_atomic_fetch_and_nbst(int64_t &retval , int64_t ** target, int64_t* value, int* pe) {
        retval = nvshmem_int64_atomic_fetch_and(*target, *value, *pe);
        return 0;
    }
        """


    _Z30nvshmem_int64_atomic_fetch_and_nbst = declare_device(
        '_Z30nvshmem_int64_atomic_fetch_and_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z30nvshmem_int64_atomic_fetch_and_nbst_caller(arg_0, arg_1, arg_2):
        return _Z30nvshmem_int64_atomic_fetch_and_nbst(arg_0, arg_1, arg_2)
    

    @lower(int64_atomic_fetch_and, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmem_int64_atomic_fetch_and_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_int64_atomic_fetch_and_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmem_int64_atomic_fetch_and_nbst(shim_stream, shim_obj)


def uint32_atomic_fetch_and():
    pass
    

def _lower__Z31nvshmem_uint32_atomic_fetch_and_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmem_uint32_atomic_fetch_and_nbst(uint32_t &retval , uint32_t ** target, uint32_t* value, int* pe) {
        retval = nvshmem_uint32_atomic_fetch_and(*target, *value, *pe);
        return 0;
    }
        """


    _Z31nvshmem_uint32_atomic_fetch_and_nbst = declare_device(
        '_Z31nvshmem_uint32_atomic_fetch_and_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z31nvshmem_uint32_atomic_fetch_and_nbst_caller(arg_0, arg_1, arg_2):
        return _Z31nvshmem_uint32_atomic_fetch_and_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint32_atomic_fetch_and, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmem_uint32_atomic_fetch_and_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmem_uint32_atomic_fetch_and_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmem_uint32_atomic_fetch_and_nbst(shim_stream, shim_obj)


def uint64_atomic_fetch_and():
    pass
    

def _lower__Z31nvshmem_uint64_atomic_fetch_and_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmem_uint64_atomic_fetch_and_nbst(uint64_t &retval , uint64_t ** target, uint64_t* value, int* pe) {
        retval = nvshmem_uint64_atomic_fetch_and(*target, *value, *pe);
        return 0;
    }
        """


    _Z31nvshmem_uint64_atomic_fetch_and_nbst = declare_device(
        '_Z31nvshmem_uint64_atomic_fetch_and_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z31nvshmem_uint64_atomic_fetch_and_nbst_caller(arg_0, arg_1, arg_2):
        return _Z31nvshmem_uint64_atomic_fetch_and_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint64_atomic_fetch_and, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmem_uint64_atomic_fetch_and_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmem_uint64_atomic_fetch_and_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmem_uint64_atomic_fetch_and_nbst(shim_stream, shim_obj)


def uint_atomic_and():
    pass
    

def _lower__Z23nvshmem_uint_atomic_and_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_uint_atomic_and_nbst(int &retval , unsigned int ** target, unsigned int* value, int* pe) {
        nvshmem_uint_atomic_and(*target, *value, *pe);
        return 0;
    }
        """


    _Z23nvshmem_uint_atomic_and_nbst = declare_device(
        '_Z23nvshmem_uint_atomic_and_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_uint_atomic_and_nbst_caller(arg_0, arg_1, arg_2):
        return _Z23nvshmem_uint_atomic_and_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint_atomic_and, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_uint_atomic_and_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_uint_atomic_and_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_uint_atomic_and_nbst(shim_stream, shim_obj)


def ulong_atomic_and():
    pass
    

def _lower__Z24nvshmem_ulong_atomic_and_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_ulong_atomic_and_nbst(int &retval , unsigned long ** target, unsigned long* value, int* pe) {
        nvshmem_ulong_atomic_and(*target, *value, *pe);
        return 0;
    }
        """


    _Z24nvshmem_ulong_atomic_and_nbst = declare_device(
        '_Z24nvshmem_ulong_atomic_and_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_ulong_atomic_and_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_ulong_atomic_and_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulong_atomic_and, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_ulong_atomic_and_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_ulong_atomic_and_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_ulong_atomic_and_nbst(shim_stream, shim_obj)


def ulonglong_atomic_and():
    pass
    

def _lower__Z28nvshmem_ulonglong_atomic_and_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_ulonglong_atomic_and_nbst(int &retval , unsigned long long ** target, unsigned long long* value, int* pe) {
        nvshmem_ulonglong_atomic_and(*target, *value, *pe);
        return 0;
    }
        """


    _Z28nvshmem_ulonglong_atomic_and_nbst = declare_device(
        '_Z28nvshmem_ulonglong_atomic_and_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_ulonglong_atomic_and_nbst_caller(arg_0, arg_1, arg_2):
        return _Z28nvshmem_ulonglong_atomic_and_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulonglong_atomic_and, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_ulonglong_atomic_and_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_ulonglong_atomic_and_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_ulonglong_atomic_and_nbst(shim_stream, shim_obj)


def int32_atomic_and():
    pass
    

def _lower__Z24nvshmem_int32_atomic_and_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_int32_atomic_and_nbst(int &retval , int32_t ** target, int32_t* value, int* pe) {
        nvshmem_int32_atomic_and(*target, *value, *pe);
        return 0;
    }
        """


    _Z24nvshmem_int32_atomic_and_nbst = declare_device(
        '_Z24nvshmem_int32_atomic_and_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_int32_atomic_and_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_int32_atomic_and_nbst(arg_0, arg_1, arg_2)
    

    @lower(int32_atomic_and, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_int32_atomic_and_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_int32_atomic_and_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_int32_atomic_and_nbst(shim_stream, shim_obj)


def int64_atomic_and():
    pass
    

def _lower__Z24nvshmem_int64_atomic_and_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_int64_atomic_and_nbst(int &retval , int64_t ** target, int64_t* value, int* pe) {
        nvshmem_int64_atomic_and(*target, *value, *pe);
        return 0;
    }
        """


    _Z24nvshmem_int64_atomic_and_nbst = declare_device(
        '_Z24nvshmem_int64_atomic_and_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_int64_atomic_and_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_int64_atomic_and_nbst(arg_0, arg_1, arg_2)
    

    @lower(int64_atomic_and, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_int64_atomic_and_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_int64_atomic_and_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_int64_atomic_and_nbst(shim_stream, shim_obj)


def uint32_atomic_and():
    pass
    

def _lower__Z25nvshmem_uint32_atomic_and_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_uint32_atomic_and_nbst(int &retval , uint32_t ** target, uint32_t* value, int* pe) {
        nvshmem_uint32_atomic_and(*target, *value, *pe);
        return 0;
    }
        """


    _Z25nvshmem_uint32_atomic_and_nbst = declare_device(
        '_Z25nvshmem_uint32_atomic_and_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_uint32_atomic_and_nbst_caller(arg_0, arg_1, arg_2):
        return _Z25nvshmem_uint32_atomic_and_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint32_atomic_and, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_uint32_atomic_and_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_uint32_atomic_and_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_uint32_atomic_and_nbst(shim_stream, shim_obj)


def uint64_atomic_and():
    pass
    

def _lower__Z25nvshmem_uint64_atomic_and_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_uint64_atomic_and_nbst(int &retval , uint64_t ** target, uint64_t* value, int* pe) {
        nvshmem_uint64_atomic_and(*target, *value, *pe);
        return 0;
    }
        """


    _Z25nvshmem_uint64_atomic_and_nbst = declare_device(
        '_Z25nvshmem_uint64_atomic_and_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_uint64_atomic_and_nbst_caller(arg_0, arg_1, arg_2):
        return _Z25nvshmem_uint64_atomic_and_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint64_atomic_and, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_uint64_atomic_and_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_uint64_atomic_and_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_uint64_atomic_and_nbst(shim_stream, shim_obj)


def uint_atomic_fetch_or():
    pass
    

def _lower__Z28nvshmem_uint_atomic_fetch_or_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_uint_atomic_fetch_or_nbst(unsigned int &retval , unsigned int ** target, unsigned int* value, int* pe) {
        retval = nvshmem_uint_atomic_fetch_or(*target, *value, *pe);
        return 0;
    }
        """


    _Z28nvshmem_uint_atomic_fetch_or_nbst = declare_device(
        '_Z28nvshmem_uint_atomic_fetch_or_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_uint_atomic_fetch_or_nbst_caller(arg_0, arg_1, arg_2):
        return _Z28nvshmem_uint_atomic_fetch_or_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint_atomic_fetch_or, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_uint_atomic_fetch_or_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_uint_atomic_fetch_or_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_uint_atomic_fetch_or_nbst(shim_stream, shim_obj)


def ulong_atomic_fetch_or():
    pass
    

def _lower__Z29nvshmem_ulong_atomic_fetch_or_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_ulong_atomic_fetch_or_nbst(unsigned long &retval , unsigned long ** target, unsigned long* value, int* pe) {
        retval = nvshmem_ulong_atomic_fetch_or(*target, *value, *pe);
        return 0;
    }
        """


    _Z29nvshmem_ulong_atomic_fetch_or_nbst = declare_device(
        '_Z29nvshmem_ulong_atomic_fetch_or_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z29nvshmem_ulong_atomic_fetch_or_nbst_caller(arg_0, arg_1, arg_2):
        return _Z29nvshmem_ulong_atomic_fetch_or_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulong_atomic_fetch_or, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmem_ulong_atomic_fetch_or_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_ulong_atomic_fetch_or_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmem_ulong_atomic_fetch_or_nbst(shim_stream, shim_obj)


def ulonglong_atomic_fetch_or():
    pass
    

def _lower__Z33nvshmem_ulonglong_atomic_fetch_or_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmem_ulonglong_atomic_fetch_or_nbst(unsigned long long &retval , unsigned long long ** target, unsigned long long* value, int* pe) {
        retval = nvshmem_ulonglong_atomic_fetch_or(*target, *value, *pe);
        return 0;
    }
        """


    _Z33nvshmem_ulonglong_atomic_fetch_or_nbst = declare_device(
        '_Z33nvshmem_ulonglong_atomic_fetch_or_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z33nvshmem_ulonglong_atomic_fetch_or_nbst_caller(arg_0, arg_1, arg_2):
        return _Z33nvshmem_ulonglong_atomic_fetch_or_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulonglong_atomic_fetch_or, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmem_ulonglong_atomic_fetch_or_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmem_ulonglong_atomic_fetch_or_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmem_ulonglong_atomic_fetch_or_nbst(shim_stream, shim_obj)


def int32_atomic_fetch_or():
    pass
    

def _lower__Z29nvshmem_int32_atomic_fetch_or_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_int32_atomic_fetch_or_nbst(int32_t &retval , int32_t ** target, int32_t* value, int* pe) {
        retval = nvshmem_int32_atomic_fetch_or(*target, *value, *pe);
        return 0;
    }
        """


    _Z29nvshmem_int32_atomic_fetch_or_nbst = declare_device(
        '_Z29nvshmem_int32_atomic_fetch_or_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmem_int32_atomic_fetch_or_nbst_caller(arg_0, arg_1, arg_2):
        return _Z29nvshmem_int32_atomic_fetch_or_nbst(arg_0, arg_1, arg_2)
    

    @lower(int32_atomic_fetch_or, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmem_int32_atomic_fetch_or_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_int32_atomic_fetch_or_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmem_int32_atomic_fetch_or_nbst(shim_stream, shim_obj)


def int64_atomic_fetch_or():
    pass
    

def _lower__Z29nvshmem_int64_atomic_fetch_or_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_int64_atomic_fetch_or_nbst(int64_t &retval , int64_t ** target, int64_t* value, int* pe) {
        retval = nvshmem_int64_atomic_fetch_or(*target, *value, *pe);
        return 0;
    }
        """


    _Z29nvshmem_int64_atomic_fetch_or_nbst = declare_device(
        '_Z29nvshmem_int64_atomic_fetch_or_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z29nvshmem_int64_atomic_fetch_or_nbst_caller(arg_0, arg_1, arg_2):
        return _Z29nvshmem_int64_atomic_fetch_or_nbst(arg_0, arg_1, arg_2)
    

    @lower(int64_atomic_fetch_or, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmem_int64_atomic_fetch_or_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_int64_atomic_fetch_or_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmem_int64_atomic_fetch_or_nbst(shim_stream, shim_obj)


def uint32_atomic_fetch_or():
    pass
    

def _lower__Z30nvshmem_uint32_atomic_fetch_or_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_uint32_atomic_fetch_or_nbst(uint32_t &retval , uint32_t ** target, uint32_t* value, int* pe) {
        retval = nvshmem_uint32_atomic_fetch_or(*target, *value, *pe);
        return 0;
    }
        """


    _Z30nvshmem_uint32_atomic_fetch_or_nbst = declare_device(
        '_Z30nvshmem_uint32_atomic_fetch_or_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z30nvshmem_uint32_atomic_fetch_or_nbst_caller(arg_0, arg_1, arg_2):
        return _Z30nvshmem_uint32_atomic_fetch_or_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint32_atomic_fetch_or, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmem_uint32_atomic_fetch_or_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_uint32_atomic_fetch_or_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmem_uint32_atomic_fetch_or_nbst(shim_stream, shim_obj)


def uint64_atomic_fetch_or():
    pass
    

def _lower__Z30nvshmem_uint64_atomic_fetch_or_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_uint64_atomic_fetch_or_nbst(uint64_t &retval , uint64_t ** target, uint64_t* value, int* pe) {
        retval = nvshmem_uint64_atomic_fetch_or(*target, *value, *pe);
        return 0;
    }
        """


    _Z30nvshmem_uint64_atomic_fetch_or_nbst = declare_device(
        '_Z30nvshmem_uint64_atomic_fetch_or_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z30nvshmem_uint64_atomic_fetch_or_nbst_caller(arg_0, arg_1, arg_2):
        return _Z30nvshmem_uint64_atomic_fetch_or_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint64_atomic_fetch_or, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmem_uint64_atomic_fetch_or_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_uint64_atomic_fetch_or_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmem_uint64_atomic_fetch_or_nbst(shim_stream, shim_obj)


def uint_atomic_or():
    pass
    

def _lower__Z22nvshmem_uint_atomic_or_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_uint_atomic_or_nbst(int &retval , unsigned int ** target, unsigned int* value, int* pe) {
        nvshmem_uint_atomic_or(*target, *value, *pe);
        return 0;
    }
        """


    _Z22nvshmem_uint_atomic_or_nbst = declare_device(
        '_Z22nvshmem_uint_atomic_or_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_uint_atomic_or_nbst_caller(arg_0, arg_1, arg_2):
        return _Z22nvshmem_uint_atomic_or_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint_atomic_or, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmem_uint_atomic_or_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_uint_atomic_or_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_uint_atomic_or_nbst(shim_stream, shim_obj)


def ulong_atomic_or():
    pass
    

def _lower__Z23nvshmem_ulong_atomic_or_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_ulong_atomic_or_nbst(int &retval , unsigned long ** target, unsigned long* value, int* pe) {
        nvshmem_ulong_atomic_or(*target, *value, *pe);
        return 0;
    }
        """


    _Z23nvshmem_ulong_atomic_or_nbst = declare_device(
        '_Z23nvshmem_ulong_atomic_or_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_ulong_atomic_or_nbst_caller(arg_0, arg_1, arg_2):
        return _Z23nvshmem_ulong_atomic_or_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulong_atomic_or, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_ulong_atomic_or_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_ulong_atomic_or_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_ulong_atomic_or_nbst(shim_stream, shim_obj)


def ulonglong_atomic_or():
    pass
    

def _lower__Z27nvshmem_ulonglong_atomic_or_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_ulonglong_atomic_or_nbst(int &retval , unsigned long long ** target, unsigned long long* value, int* pe) {
        nvshmem_ulonglong_atomic_or(*target, *value, *pe);
        return 0;
    }
        """


    _Z27nvshmem_ulonglong_atomic_or_nbst = declare_device(
        '_Z27nvshmem_ulonglong_atomic_or_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmem_ulonglong_atomic_or_nbst_caller(arg_0, arg_1, arg_2):
        return _Z27nvshmem_ulonglong_atomic_or_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulonglong_atomic_or, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmem_ulonglong_atomic_or_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_ulonglong_atomic_or_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmem_ulonglong_atomic_or_nbst(shim_stream, shim_obj)


def int32_atomic_or():
    pass
    

def _lower__Z23nvshmem_int32_atomic_or_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_int32_atomic_or_nbst(int &retval , int32_t ** target, int32_t* value, int* pe) {
        nvshmem_int32_atomic_or(*target, *value, *pe);
        return 0;
    }
        """


    _Z23nvshmem_int32_atomic_or_nbst = declare_device(
        '_Z23nvshmem_int32_atomic_or_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_int32_atomic_or_nbst_caller(arg_0, arg_1, arg_2):
        return _Z23nvshmem_int32_atomic_or_nbst(arg_0, arg_1, arg_2)
    

    @lower(int32_atomic_or, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_int32_atomic_or_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_int32_atomic_or_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_int32_atomic_or_nbst(shim_stream, shim_obj)


def int64_atomic_or():
    pass
    

def _lower__Z23nvshmem_int64_atomic_or_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_int64_atomic_or_nbst(int &retval , int64_t ** target, int64_t* value, int* pe) {
        nvshmem_int64_atomic_or(*target, *value, *pe);
        return 0;
    }
        """


    _Z23nvshmem_int64_atomic_or_nbst = declare_device(
        '_Z23nvshmem_int64_atomic_or_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_int64_atomic_or_nbst_caller(arg_0, arg_1, arg_2):
        return _Z23nvshmem_int64_atomic_or_nbst(arg_0, arg_1, arg_2)
    

    @lower(int64_atomic_or, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_int64_atomic_or_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_int64_atomic_or_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_int64_atomic_or_nbst(shim_stream, shim_obj)


def uint32_atomic_or():
    pass
    

def _lower__Z24nvshmem_uint32_atomic_or_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_uint32_atomic_or_nbst(int &retval , uint32_t ** target, uint32_t* value, int* pe) {
        nvshmem_uint32_atomic_or(*target, *value, *pe);
        return 0;
    }
        """


    _Z24nvshmem_uint32_atomic_or_nbst = declare_device(
        '_Z24nvshmem_uint32_atomic_or_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_uint32_atomic_or_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_uint32_atomic_or_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint32_atomic_or, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_uint32_atomic_or_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_uint32_atomic_or_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_uint32_atomic_or_nbst(shim_stream, shim_obj)


def uint64_atomic_or():
    pass
    

def _lower__Z24nvshmem_uint64_atomic_or_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_uint64_atomic_or_nbst(int &retval , uint64_t ** target, uint64_t* value, int* pe) {
        nvshmem_uint64_atomic_or(*target, *value, *pe);
        return 0;
    }
        """


    _Z24nvshmem_uint64_atomic_or_nbst = declare_device(
        '_Z24nvshmem_uint64_atomic_or_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_uint64_atomic_or_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_uint64_atomic_or_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint64_atomic_or, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_uint64_atomic_or_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_uint64_atomic_or_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_uint64_atomic_or_nbst(shim_stream, shim_obj)


def uint_atomic_fetch_xor():
    pass
    

def _lower__Z29nvshmem_uint_atomic_fetch_xor_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_uint_atomic_fetch_xor_nbst(unsigned int &retval , unsigned int ** target, unsigned int* value, int* pe) {
        retval = nvshmem_uint_atomic_fetch_xor(*target, *value, *pe);
        return 0;
    }
        """


    _Z29nvshmem_uint_atomic_fetch_xor_nbst = declare_device(
        '_Z29nvshmem_uint_atomic_fetch_xor_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z29nvshmem_uint_atomic_fetch_xor_nbst_caller(arg_0, arg_1, arg_2):
        return _Z29nvshmem_uint_atomic_fetch_xor_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint_atomic_fetch_xor, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmem_uint_atomic_fetch_xor_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_uint_atomic_fetch_xor_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmem_uint_atomic_fetch_xor_nbst(shim_stream, shim_obj)


def ulong_atomic_fetch_xor():
    pass
    

def _lower__Z30nvshmem_ulong_atomic_fetch_xor_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_ulong_atomic_fetch_xor_nbst(unsigned long &retval , unsigned long ** target, unsigned long* value, int* pe) {
        retval = nvshmem_ulong_atomic_fetch_xor(*target, *value, *pe);
        return 0;
    }
        """


    _Z30nvshmem_ulong_atomic_fetch_xor_nbst = declare_device(
        '_Z30nvshmem_ulong_atomic_fetch_xor_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z30nvshmem_ulong_atomic_fetch_xor_nbst_caller(arg_0, arg_1, arg_2):
        return _Z30nvshmem_ulong_atomic_fetch_xor_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulong_atomic_fetch_xor, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmem_ulong_atomic_fetch_xor_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_ulong_atomic_fetch_xor_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmem_ulong_atomic_fetch_xor_nbst(shim_stream, shim_obj)


def ulonglong_atomic_fetch_xor():
    pass
    

def _lower__Z34nvshmem_ulonglong_atomic_fetch_xor_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmem_ulonglong_atomic_fetch_xor_nbst(unsigned long long &retval , unsigned long long ** target, unsigned long long* value, int* pe) {
        retval = nvshmem_ulonglong_atomic_fetch_xor(*target, *value, *pe);
        return 0;
    }
        """


    _Z34nvshmem_ulonglong_atomic_fetch_xor_nbst = declare_device(
        '_Z34nvshmem_ulonglong_atomic_fetch_xor_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z34nvshmem_ulonglong_atomic_fetch_xor_nbst_caller(arg_0, arg_1, arg_2):
        return _Z34nvshmem_ulonglong_atomic_fetch_xor_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulonglong_atomic_fetch_xor, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmem_ulonglong_atomic_fetch_xor_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmem_ulonglong_atomic_fetch_xor_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmem_ulonglong_atomic_fetch_xor_nbst(shim_stream, shim_obj)


def int32_atomic_fetch_xor():
    pass
    

def _lower__Z30nvshmem_int32_atomic_fetch_xor_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_int32_atomic_fetch_xor_nbst(int32_t &retval , int32_t ** target, int32_t* value, int* pe) {
        retval = nvshmem_int32_atomic_fetch_xor(*target, *value, *pe);
        return 0;
    }
        """


    _Z30nvshmem_int32_atomic_fetch_xor_nbst = declare_device(
        '_Z30nvshmem_int32_atomic_fetch_xor_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmem_int32_atomic_fetch_xor_nbst_caller(arg_0, arg_1, arg_2):
        return _Z30nvshmem_int32_atomic_fetch_xor_nbst(arg_0, arg_1, arg_2)
    

    @lower(int32_atomic_fetch_xor, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmem_int32_atomic_fetch_xor_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_int32_atomic_fetch_xor_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmem_int32_atomic_fetch_xor_nbst(shim_stream, shim_obj)


def int64_atomic_fetch_xor():
    pass
    

def _lower__Z30nvshmem_int64_atomic_fetch_xor_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_int64_atomic_fetch_xor_nbst(int64_t &retval , int64_t ** target, int64_t* value, int* pe) {
        retval = nvshmem_int64_atomic_fetch_xor(*target, *value, *pe);
        return 0;
    }
        """


    _Z30nvshmem_int64_atomic_fetch_xor_nbst = declare_device(
        '_Z30nvshmem_int64_atomic_fetch_xor_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z30nvshmem_int64_atomic_fetch_xor_nbst_caller(arg_0, arg_1, arg_2):
        return _Z30nvshmem_int64_atomic_fetch_xor_nbst(arg_0, arg_1, arg_2)
    

    @lower(int64_atomic_fetch_xor, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmem_int64_atomic_fetch_xor_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_int64_atomic_fetch_xor_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmem_int64_atomic_fetch_xor_nbst(shim_stream, shim_obj)


def uint32_atomic_fetch_xor():
    pass
    

def _lower__Z31nvshmem_uint32_atomic_fetch_xor_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmem_uint32_atomic_fetch_xor_nbst(uint32_t &retval , uint32_t ** target, uint32_t* value, int* pe) {
        retval = nvshmem_uint32_atomic_fetch_xor(*target, *value, *pe);
        return 0;
    }
        """


    _Z31nvshmem_uint32_atomic_fetch_xor_nbst = declare_device(
        '_Z31nvshmem_uint32_atomic_fetch_xor_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z31nvshmem_uint32_atomic_fetch_xor_nbst_caller(arg_0, arg_1, arg_2):
        return _Z31nvshmem_uint32_atomic_fetch_xor_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint32_atomic_fetch_xor, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmem_uint32_atomic_fetch_xor_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmem_uint32_atomic_fetch_xor_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmem_uint32_atomic_fetch_xor_nbst(shim_stream, shim_obj)


def uint64_atomic_fetch_xor():
    pass
    

def _lower__Z31nvshmem_uint64_atomic_fetch_xor_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmem_uint64_atomic_fetch_xor_nbst(uint64_t &retval , uint64_t ** target, uint64_t* value, int* pe) {
        retval = nvshmem_uint64_atomic_fetch_xor(*target, *value, *pe);
        return 0;
    }
        """


    _Z31nvshmem_uint64_atomic_fetch_xor_nbst = declare_device(
        '_Z31nvshmem_uint64_atomic_fetch_xor_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z31nvshmem_uint64_atomic_fetch_xor_nbst_caller(arg_0, arg_1, arg_2):
        return _Z31nvshmem_uint64_atomic_fetch_xor_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint64_atomic_fetch_xor, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmem_uint64_atomic_fetch_xor_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmem_uint64_atomic_fetch_xor_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmem_uint64_atomic_fetch_xor_nbst(shim_stream, shim_obj)


def uint_atomic_xor():
    pass
    

def _lower__Z23nvshmem_uint_atomic_xor_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_uint_atomic_xor_nbst(int &retval , unsigned int ** target, unsigned int* value, int* pe) {
        nvshmem_uint_atomic_xor(*target, *value, *pe);
        return 0;
    }
        """


    _Z23nvshmem_uint_atomic_xor_nbst = declare_device(
        '_Z23nvshmem_uint_atomic_xor_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_uint_atomic_xor_nbst_caller(arg_0, arg_1, arg_2):
        return _Z23nvshmem_uint_atomic_xor_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint_atomic_xor, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_uint_atomic_xor_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_uint_atomic_xor_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_uint_atomic_xor_nbst(shim_stream, shim_obj)


def ulong_atomic_xor():
    pass
    

def _lower__Z24nvshmem_ulong_atomic_xor_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_ulong_atomic_xor_nbst(int &retval , unsigned long ** target, unsigned long* value, int* pe) {
        nvshmem_ulong_atomic_xor(*target, *value, *pe);
        return 0;
    }
        """


    _Z24nvshmem_ulong_atomic_xor_nbst = declare_device(
        '_Z24nvshmem_ulong_atomic_xor_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_ulong_atomic_xor_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_ulong_atomic_xor_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulong_atomic_xor, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_ulong_atomic_xor_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_ulong_atomic_xor_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_ulong_atomic_xor_nbst(shim_stream, shim_obj)


def ulonglong_atomic_xor():
    pass
    

def _lower__Z28nvshmem_ulonglong_atomic_xor_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_ulonglong_atomic_xor_nbst(int &retval , unsigned long long ** target, unsigned long long* value, int* pe) {
        nvshmem_ulonglong_atomic_xor(*target, *value, *pe);
        return 0;
    }
        """


    _Z28nvshmem_ulonglong_atomic_xor_nbst = declare_device(
        '_Z28nvshmem_ulonglong_atomic_xor_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_ulonglong_atomic_xor_nbst_caller(arg_0, arg_1, arg_2):
        return _Z28nvshmem_ulonglong_atomic_xor_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulonglong_atomic_xor, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_ulonglong_atomic_xor_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_ulonglong_atomic_xor_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_ulonglong_atomic_xor_nbst(shim_stream, shim_obj)


def int32_atomic_xor():
    pass
    

def _lower__Z24nvshmem_int32_atomic_xor_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_int32_atomic_xor_nbst(int &retval , int32_t ** target, int32_t* value, int* pe) {
        nvshmem_int32_atomic_xor(*target, *value, *pe);
        return 0;
    }
        """


    _Z24nvshmem_int32_atomic_xor_nbst = declare_device(
        '_Z24nvshmem_int32_atomic_xor_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_int32_atomic_xor_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_int32_atomic_xor_nbst(arg_0, arg_1, arg_2)
    

    @lower(int32_atomic_xor, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_int32_atomic_xor_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_int32_atomic_xor_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_int32_atomic_xor_nbst(shim_stream, shim_obj)


def int64_atomic_xor():
    pass
    

def _lower__Z24nvshmem_int64_atomic_xor_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_int64_atomic_xor_nbst(int &retval , int64_t ** target, int64_t* value, int* pe) {
        nvshmem_int64_atomic_xor(*target, *value, *pe);
        return 0;
    }
        """


    _Z24nvshmem_int64_atomic_xor_nbst = declare_device(
        '_Z24nvshmem_int64_atomic_xor_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_int64_atomic_xor_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_int64_atomic_xor_nbst(arg_0, arg_1, arg_2)
    

    @lower(int64_atomic_xor, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_int64_atomic_xor_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_int64_atomic_xor_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_int64_atomic_xor_nbst(shim_stream, shim_obj)


def uint32_atomic_xor():
    pass
    

def _lower__Z25nvshmem_uint32_atomic_xor_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_uint32_atomic_xor_nbst(int &retval , uint32_t ** target, uint32_t* value, int* pe) {
        nvshmem_uint32_atomic_xor(*target, *value, *pe);
        return 0;
    }
        """


    _Z25nvshmem_uint32_atomic_xor_nbst = declare_device(
        '_Z25nvshmem_uint32_atomic_xor_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_uint32_atomic_xor_nbst_caller(arg_0, arg_1, arg_2):
        return _Z25nvshmem_uint32_atomic_xor_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint32_atomic_xor, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_uint32_atomic_xor_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_uint32_atomic_xor_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_uint32_atomic_xor_nbst(shim_stream, shim_obj)


def uint64_atomic_xor():
    pass
    

def _lower__Z25nvshmem_uint64_atomic_xor_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_uint64_atomic_xor_nbst(int &retval , uint64_t ** target, uint64_t* value, int* pe) {
        nvshmem_uint64_atomic_xor(*target, *value, *pe);
        return 0;
    }
        """


    _Z25nvshmem_uint64_atomic_xor_nbst = declare_device(
        '_Z25nvshmem_uint64_atomic_xor_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_uint64_atomic_xor_nbst_caller(arg_0, arg_1, arg_2):
        return _Z25nvshmem_uint64_atomic_xor_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint64_atomic_xor, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_uint64_atomic_xor_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_uint64_atomic_xor_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_uint64_atomic_xor_nbst(shim_stream, shim_obj)


def int_atomic_swap():
    pass
    

def _lower__Z23nvshmem_int_atomic_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_int_atomic_swap_nbst(int &retval , int ** target, int* value, int* pe) {
        retval = nvshmem_int_atomic_swap(*target, *value, *pe);
        return 0;
    }
        """


    _Z23nvshmem_int_atomic_swap_nbst = declare_device(
        '_Z23nvshmem_int_atomic_swap_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_int_atomic_swap_nbst_caller(arg_0, arg_1, arg_2):
        return _Z23nvshmem_int_atomic_swap_nbst(arg_0, arg_1, arg_2)
    

    @lower(int_atomic_swap, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_int_atomic_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_int_atomic_swap_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_int_atomic_swap_nbst(shim_stream, shim_obj)


def long_atomic_swap():
    pass
    

def _lower__Z24nvshmem_long_atomic_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_long_atomic_swap_nbst(long &retval , long ** target, long* value, int* pe) {
        retval = nvshmem_long_atomic_swap(*target, *value, *pe);
        return 0;
    }
        """


    _Z24nvshmem_long_atomic_swap_nbst = declare_device(
        '_Z24nvshmem_long_atomic_swap_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_long_atomic_swap_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_long_atomic_swap_nbst(arg_0, arg_1, arg_2)
    

    @lower(long_atomic_swap, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_long_atomic_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_long_atomic_swap_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_long_atomic_swap_nbst(shim_stream, shim_obj)


def longlong_atomic_swap():
    pass
    

def _lower__Z28nvshmem_longlong_atomic_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_longlong_atomic_swap_nbst(long long &retval , long long ** target, long long* value, int* pe) {
        retval = nvshmem_longlong_atomic_swap(*target, *value, *pe);
        return 0;
    }
        """


    _Z28nvshmem_longlong_atomic_swap_nbst = declare_device(
        '_Z28nvshmem_longlong_atomic_swap_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_longlong_atomic_swap_nbst_caller(arg_0, arg_1, arg_2):
        return _Z28nvshmem_longlong_atomic_swap_nbst(arg_0, arg_1, arg_2)
    

    @lower(longlong_atomic_swap, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_longlong_atomic_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_longlong_atomic_swap_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_longlong_atomic_swap_nbst(shim_stream, shim_obj)


def uint_atomic_swap():
    pass
    

def _lower__Z24nvshmem_uint_atomic_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_uint_atomic_swap_nbst(unsigned int &retval , unsigned int ** target, unsigned int* value, int* pe) {
        retval = nvshmem_uint_atomic_swap(*target, *value, *pe);
        return 0;
    }
        """


    _Z24nvshmem_uint_atomic_swap_nbst = declare_device(
        '_Z24nvshmem_uint_atomic_swap_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_uint_atomic_swap_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_uint_atomic_swap_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint_atomic_swap, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_uint_atomic_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_uint_atomic_swap_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_uint_atomic_swap_nbst(shim_stream, shim_obj)


def ulong_atomic_swap():
    pass
    

def _lower__Z25nvshmem_ulong_atomic_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_ulong_atomic_swap_nbst(unsigned long &retval , unsigned long ** target, unsigned long* value, int* pe) {
        retval = nvshmem_ulong_atomic_swap(*target, *value, *pe);
        return 0;
    }
        """


    _Z25nvshmem_ulong_atomic_swap_nbst = declare_device(
        '_Z25nvshmem_ulong_atomic_swap_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_ulong_atomic_swap_nbst_caller(arg_0, arg_1, arg_2):
        return _Z25nvshmem_ulong_atomic_swap_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulong_atomic_swap, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_ulong_atomic_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_ulong_atomic_swap_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_ulong_atomic_swap_nbst(shim_stream, shim_obj)


def ulonglong_atomic_swap():
    pass
    

def _lower__Z29nvshmem_ulonglong_atomic_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_ulonglong_atomic_swap_nbst(unsigned long long &retval , unsigned long long ** target, unsigned long long* value, int* pe) {
        retval = nvshmem_ulonglong_atomic_swap(*target, *value, *pe);
        return 0;
    }
        """


    _Z29nvshmem_ulonglong_atomic_swap_nbst = declare_device(
        '_Z29nvshmem_ulonglong_atomic_swap_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z29nvshmem_ulonglong_atomic_swap_nbst_caller(arg_0, arg_1, arg_2):
        return _Z29nvshmem_ulonglong_atomic_swap_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulonglong_atomic_swap, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmem_ulonglong_atomic_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_ulonglong_atomic_swap_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmem_ulonglong_atomic_swap_nbst(shim_stream, shim_obj)


def int32_atomic_swap():
    pass
    

def _lower__Z25nvshmem_int32_atomic_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_int32_atomic_swap_nbst(int32_t &retval , int32_t ** target, int32_t* value, int* pe) {
        retval = nvshmem_int32_atomic_swap(*target, *value, *pe);
        return 0;
    }
        """


    _Z25nvshmem_int32_atomic_swap_nbst = declare_device(
        '_Z25nvshmem_int32_atomic_swap_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_int32_atomic_swap_nbst_caller(arg_0, arg_1, arg_2):
        return _Z25nvshmem_int32_atomic_swap_nbst(arg_0, arg_1, arg_2)
    

    @lower(int32_atomic_swap, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_int32_atomic_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_int32_atomic_swap_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_int32_atomic_swap_nbst(shim_stream, shim_obj)


def int64_atomic_swap():
    pass
    

def _lower__Z25nvshmem_int64_atomic_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_int64_atomic_swap_nbst(int64_t &retval , int64_t ** target, int64_t* value, int* pe) {
        retval = nvshmem_int64_atomic_swap(*target, *value, *pe);
        return 0;
    }
        """


    _Z25nvshmem_int64_atomic_swap_nbst = declare_device(
        '_Z25nvshmem_int64_atomic_swap_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_int64_atomic_swap_nbst_caller(arg_0, arg_1, arg_2):
        return _Z25nvshmem_int64_atomic_swap_nbst(arg_0, arg_1, arg_2)
    

    @lower(int64_atomic_swap, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_int64_atomic_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_int64_atomic_swap_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_int64_atomic_swap_nbst(shim_stream, shim_obj)


def uint32_atomic_swap():
    pass
    

def _lower__Z26nvshmem_uint32_atomic_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmem_uint32_atomic_swap_nbst(uint32_t &retval , uint32_t ** target, uint32_t* value, int* pe) {
        retval = nvshmem_uint32_atomic_swap(*target, *value, *pe);
        return 0;
    }
        """


    _Z26nvshmem_uint32_atomic_swap_nbst = declare_device(
        '_Z26nvshmem_uint32_atomic_swap_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z26nvshmem_uint32_atomic_swap_nbst_caller(arg_0, arg_1, arg_2):
        return _Z26nvshmem_uint32_atomic_swap_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint32_atomic_swap, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmem_uint32_atomic_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmem_uint32_atomic_swap_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmem_uint32_atomic_swap_nbst(shim_stream, shim_obj)


def uint64_atomic_swap():
    pass
    

def _lower__Z26nvshmem_uint64_atomic_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmem_uint64_atomic_swap_nbst(uint64_t &retval , uint64_t ** target, uint64_t* value, int* pe) {
        retval = nvshmem_uint64_atomic_swap(*target, *value, *pe);
        return 0;
    }
        """


    _Z26nvshmem_uint64_atomic_swap_nbst = declare_device(
        '_Z26nvshmem_uint64_atomic_swap_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmem_uint64_atomic_swap_nbst_caller(arg_0, arg_1, arg_2):
        return _Z26nvshmem_uint64_atomic_swap_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint64_atomic_swap, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmem_uint64_atomic_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmem_uint64_atomic_swap_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmem_uint64_atomic_swap_nbst(shim_stream, shim_obj)


def float_atomic_swap():
    pass
    

def _lower__Z25nvshmem_float_atomic_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_float_atomic_swap_nbst(float &retval , float ** target, float* value, int* pe) {
        retval = nvshmem_float_atomic_swap(*target, *value, *pe);
        return 0;
    }
        """


    _Z25nvshmem_float_atomic_swap_nbst = declare_device(
        '_Z25nvshmem_float_atomic_swap_nbst',
        float32(
            CPointer(CPointer(float32)), CPointer(float32), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_float_atomic_swap_nbst_caller(arg_0, arg_1, arg_2):
        return _Z25nvshmem_float_atomic_swap_nbst(arg_0, arg_1, arg_2)
    

    @lower(float_atomic_swap, CPointer(float32), float32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_float_atomic_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_float_atomic_swap_nbst_caller,
            signature(float32, CPointer(CPointer(float32)), CPointer(float32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_float_atomic_swap_nbst(shim_stream, shim_obj)


def double_atomic_swap():
    pass
    

def _lower__Z26nvshmem_double_atomic_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmem_double_atomic_swap_nbst(double &retval , double ** target, double* value, int* pe) {
        retval = nvshmem_double_atomic_swap(*target, *value, *pe);
        return 0;
    }
        """


    _Z26nvshmem_double_atomic_swap_nbst = declare_device(
        '_Z26nvshmem_double_atomic_swap_nbst',
        float64(
            CPointer(CPointer(float64)), CPointer(float64), CPointer(int32)
        )
    )
    

    def _Z26nvshmem_double_atomic_swap_nbst_caller(arg_0, arg_1, arg_2):
        return _Z26nvshmem_double_atomic_swap_nbst(arg_0, arg_1, arg_2)
    

    @lower(double_atomic_swap, CPointer(float64), float64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmem_double_atomic_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmem_double_atomic_swap_nbst_caller,
            signature(float64, CPointer(CPointer(float64)), CPointer(float64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmem_double_atomic_swap_nbst(shim_stream, shim_obj)


def size_atomic_swap():
    pass
    

def _lower__Z24nvshmem_size_atomic_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_size_atomic_swap_nbst(unsigned long &retval , unsigned long ** target, unsigned long* value, int* pe) {
        retval = nvshmem_size_atomic_swap(*target, *value, *pe);
        return 0;
    }
        """


    _Z24nvshmem_size_atomic_swap_nbst = declare_device(
        '_Z24nvshmem_size_atomic_swap_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_size_atomic_swap_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_size_atomic_swap_nbst(arg_0, arg_1, arg_2)
    

    @lower(size_atomic_swap, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_size_atomic_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_size_atomic_swap_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_size_atomic_swap_nbst(shim_stream, shim_obj)


def ptrdiff_atomic_swap():
    pass
    

def _lower__Z27nvshmem_ptrdiff_atomic_swap_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_ptrdiff_atomic_swap_nbst(long &retval , long ** target, long* value, int* pe) {
        retval = nvshmem_ptrdiff_atomic_swap(*target, *value, *pe);
        return 0;
    }
        """


    _Z27nvshmem_ptrdiff_atomic_swap_nbst = declare_device(
        '_Z27nvshmem_ptrdiff_atomic_swap_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z27nvshmem_ptrdiff_atomic_swap_nbst_caller(arg_0, arg_1, arg_2):
        return _Z27nvshmem_ptrdiff_atomic_swap_nbst(arg_0, arg_1, arg_2)
    

    @lower(ptrdiff_atomic_swap, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmem_ptrdiff_atomic_swap_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_ptrdiff_atomic_swap_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmem_ptrdiff_atomic_swap_nbst(shim_stream, shim_obj)


def int_atomic_fetch():
    pass
    

def _lower__Z24nvshmem_int_atomic_fetch_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_int_atomic_fetch_nbst(int &retval , int ** target, int* pe) {
        retval = nvshmem_int_atomic_fetch(*target, *pe);
        return 0;
    }
        """


    _Z24nvshmem_int_atomic_fetch_nbst = declare_device(
        '_Z24nvshmem_int_atomic_fetch_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_int_atomic_fetch_nbst_caller(arg_0, arg_1):
        return _Z24nvshmem_int_atomic_fetch_nbst(arg_0, arg_1)
    

    @lower(int_atomic_fetch, CPointer(int32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_int_atomic_fetch_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_int_atomic_fetch_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_int_atomic_fetch_nbst(shim_stream, shim_obj)


def long_atomic_fetch():
    pass
    

def _lower__Z25nvshmem_long_atomic_fetch_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_long_atomic_fetch_nbst(long &retval , long ** target, int* pe) {
        retval = nvshmem_long_atomic_fetch(*target, *pe);
        return 0;
    }
        """


    _Z25nvshmem_long_atomic_fetch_nbst = declare_device(
        '_Z25nvshmem_long_atomic_fetch_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_long_atomic_fetch_nbst_caller(arg_0, arg_1):
        return _Z25nvshmem_long_atomic_fetch_nbst(arg_0, arg_1)
    

    @lower(long_atomic_fetch, CPointer(int64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_long_atomic_fetch_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_long_atomic_fetch_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_long_atomic_fetch_nbst(shim_stream, shim_obj)


def longlong_atomic_fetch():
    pass
    

def _lower__Z29nvshmem_longlong_atomic_fetch_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmem_longlong_atomic_fetch_nbst(long long &retval , long long ** target, int* pe) {
        retval = nvshmem_longlong_atomic_fetch(*target, *pe);
        return 0;
    }
        """


    _Z29nvshmem_longlong_atomic_fetch_nbst = declare_device(
        '_Z29nvshmem_longlong_atomic_fetch_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int32)
        )
    )
    

    def _Z29nvshmem_longlong_atomic_fetch_nbst_caller(arg_0, arg_1):
        return _Z29nvshmem_longlong_atomic_fetch_nbst(arg_0, arg_1)
    

    @lower(longlong_atomic_fetch, CPointer(int64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmem_longlong_atomic_fetch_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmem_longlong_atomic_fetch_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmem_longlong_atomic_fetch_nbst(shim_stream, shim_obj)


def uint_atomic_fetch():
    pass
    

def _lower__Z25nvshmem_uint_atomic_fetch_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_uint_atomic_fetch_nbst(unsigned int &retval , unsigned int ** target, int* pe) {
        retval = nvshmem_uint_atomic_fetch(*target, *pe);
        return 0;
    }
        """


    _Z25nvshmem_uint_atomic_fetch_nbst = declare_device(
        '_Z25nvshmem_uint_atomic_fetch_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_uint_atomic_fetch_nbst_caller(arg_0, arg_1):
        return _Z25nvshmem_uint_atomic_fetch_nbst(arg_0, arg_1)
    

    @lower(uint_atomic_fetch, CPointer(uint32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_uint_atomic_fetch_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_uint_atomic_fetch_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_uint_atomic_fetch_nbst(shim_stream, shim_obj)


def ulong_atomic_fetch():
    pass
    

def _lower__Z26nvshmem_ulong_atomic_fetch_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmem_ulong_atomic_fetch_nbst(unsigned long &retval , unsigned long ** target, int* pe) {
        retval = nvshmem_ulong_atomic_fetch(*target, *pe);
        return 0;
    }
        """


    _Z26nvshmem_ulong_atomic_fetch_nbst = declare_device(
        '_Z26nvshmem_ulong_atomic_fetch_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(int32)
        )
    )
    

    def _Z26nvshmem_ulong_atomic_fetch_nbst_caller(arg_0, arg_1):
        return _Z26nvshmem_ulong_atomic_fetch_nbst(arg_0, arg_1)
    

    @lower(ulong_atomic_fetch, CPointer(uint64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmem_ulong_atomic_fetch_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmem_ulong_atomic_fetch_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmem_ulong_atomic_fetch_nbst(shim_stream, shim_obj)


def ulonglong_atomic_fetch():
    pass
    

def _lower__Z30nvshmem_ulonglong_atomic_fetch_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmem_ulonglong_atomic_fetch_nbst(unsigned long long &retval , unsigned long long ** target, int* pe) {
        retval = nvshmem_ulonglong_atomic_fetch(*target, *pe);
        return 0;
    }
        """


    _Z30nvshmem_ulonglong_atomic_fetch_nbst = declare_device(
        '_Z30nvshmem_ulonglong_atomic_fetch_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(int32)
        )
    )
    

    def _Z30nvshmem_ulonglong_atomic_fetch_nbst_caller(arg_0, arg_1):
        return _Z30nvshmem_ulonglong_atomic_fetch_nbst(arg_0, arg_1)
    

    @lower(ulonglong_atomic_fetch, CPointer(uint64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmem_ulonglong_atomic_fetch_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmem_ulonglong_atomic_fetch_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmem_ulonglong_atomic_fetch_nbst(shim_stream, shim_obj)


def int32_atomic_fetch():
    pass
    

def _lower__Z26nvshmem_int32_atomic_fetch_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmem_int32_atomic_fetch_nbst(int32_t &retval , int32_t ** target, int* pe) {
        retval = nvshmem_int32_atomic_fetch(*target, *pe);
        return 0;
    }
        """


    _Z26nvshmem_int32_atomic_fetch_nbst = declare_device(
        '_Z26nvshmem_int32_atomic_fetch_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(int32)
        )
    )
    

    def _Z26nvshmem_int32_atomic_fetch_nbst_caller(arg_0, arg_1):
        return _Z26nvshmem_int32_atomic_fetch_nbst(arg_0, arg_1)
    

    @lower(int32_atomic_fetch, CPointer(int32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmem_int32_atomic_fetch_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmem_int32_atomic_fetch_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmem_int32_atomic_fetch_nbst(shim_stream, shim_obj)


def int64_atomic_fetch():
    pass
    

def _lower__Z26nvshmem_int64_atomic_fetch_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmem_int64_atomic_fetch_nbst(int64_t &retval , int64_t ** target, int* pe) {
        retval = nvshmem_int64_atomic_fetch(*target, *pe);
        return 0;
    }
        """


    _Z26nvshmem_int64_atomic_fetch_nbst = declare_device(
        '_Z26nvshmem_int64_atomic_fetch_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int32)
        )
    )
    

    def _Z26nvshmem_int64_atomic_fetch_nbst_caller(arg_0, arg_1):
        return _Z26nvshmem_int64_atomic_fetch_nbst(arg_0, arg_1)
    

    @lower(int64_atomic_fetch, CPointer(int64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmem_int64_atomic_fetch_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmem_int64_atomic_fetch_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmem_int64_atomic_fetch_nbst(shim_stream, shim_obj)


def uint32_atomic_fetch():
    pass
    

def _lower__Z27nvshmem_uint32_atomic_fetch_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_uint32_atomic_fetch_nbst(uint32_t &retval , uint32_t ** target, int* pe) {
        retval = nvshmem_uint32_atomic_fetch(*target, *pe);
        return 0;
    }
        """


    _Z27nvshmem_uint32_atomic_fetch_nbst = declare_device(
        '_Z27nvshmem_uint32_atomic_fetch_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(int32)
        )
    )
    

    def _Z27nvshmem_uint32_atomic_fetch_nbst_caller(arg_0, arg_1):
        return _Z27nvshmem_uint32_atomic_fetch_nbst(arg_0, arg_1)
    

    @lower(uint32_atomic_fetch, CPointer(uint32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmem_uint32_atomic_fetch_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_uint32_atomic_fetch_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmem_uint32_atomic_fetch_nbst(shim_stream, shim_obj)


def uint64_atomic_fetch():
    pass
    

def _lower__Z27nvshmem_uint64_atomic_fetch_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_uint64_atomic_fetch_nbst(uint64_t &retval , uint64_t ** target, int* pe) {
        retval = nvshmem_uint64_atomic_fetch(*target, *pe);
        return 0;
    }
        """


    _Z27nvshmem_uint64_atomic_fetch_nbst = declare_device(
        '_Z27nvshmem_uint64_atomic_fetch_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(int32)
        )
    )
    

    def _Z27nvshmem_uint64_atomic_fetch_nbst_caller(arg_0, arg_1):
        return _Z27nvshmem_uint64_atomic_fetch_nbst(arg_0, arg_1)
    

    @lower(uint64_atomic_fetch, CPointer(uint64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmem_uint64_atomic_fetch_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_uint64_atomic_fetch_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmem_uint64_atomic_fetch_nbst(shim_stream, shim_obj)


def float_atomic_fetch():
    pass
    

def _lower__Z26nvshmem_float_atomic_fetch_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmem_float_atomic_fetch_nbst(float &retval , float ** target, int* pe) {
        retval = nvshmem_float_atomic_fetch(*target, *pe);
        return 0;
    }
        """


    _Z26nvshmem_float_atomic_fetch_nbst = declare_device(
        '_Z26nvshmem_float_atomic_fetch_nbst',
        float32(
            CPointer(CPointer(float32)), CPointer(int32)
        )
    )
    

    def _Z26nvshmem_float_atomic_fetch_nbst_caller(arg_0, arg_1):
        return _Z26nvshmem_float_atomic_fetch_nbst(arg_0, arg_1)
    

    @lower(float_atomic_fetch, CPointer(float32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmem_float_atomic_fetch_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmem_float_atomic_fetch_nbst_caller,
            signature(float32, CPointer(CPointer(float32)), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmem_float_atomic_fetch_nbst(shim_stream, shim_obj)


def double_atomic_fetch():
    pass
    

def _lower__Z27nvshmem_double_atomic_fetch_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_double_atomic_fetch_nbst(double &retval , double ** target, int* pe) {
        retval = nvshmem_double_atomic_fetch(*target, *pe);
        return 0;
    }
        """


    _Z27nvshmem_double_atomic_fetch_nbst = declare_device(
        '_Z27nvshmem_double_atomic_fetch_nbst',
        float64(
            CPointer(CPointer(float64)), CPointer(int32)
        )
    )
    

    def _Z27nvshmem_double_atomic_fetch_nbst_caller(arg_0, arg_1):
        return _Z27nvshmem_double_atomic_fetch_nbst(arg_0, arg_1)
    

    @lower(double_atomic_fetch, CPointer(float64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmem_double_atomic_fetch_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_double_atomic_fetch_nbst_caller,
            signature(float64, CPointer(CPointer(float64)), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmem_double_atomic_fetch_nbst(shim_stream, shim_obj)


def size_atomic_fetch():
    pass
    

def _lower__Z25nvshmem_size_atomic_fetch_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_size_atomic_fetch_nbst(unsigned long &retval , unsigned long ** target, int* pe) {
        retval = nvshmem_size_atomic_fetch(*target, *pe);
        return 0;
    }
        """


    _Z25nvshmem_size_atomic_fetch_nbst = declare_device(
        '_Z25nvshmem_size_atomic_fetch_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_size_atomic_fetch_nbst_caller(arg_0, arg_1):
        return _Z25nvshmem_size_atomic_fetch_nbst(arg_0, arg_1)
    

    @lower(size_atomic_fetch, CPointer(uint64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_size_atomic_fetch_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_size_atomic_fetch_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_size_atomic_fetch_nbst(shim_stream, shim_obj)


def ptrdiff_atomic_fetch():
    pass
    

def _lower__Z28nvshmem_ptrdiff_atomic_fetch_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_ptrdiff_atomic_fetch_nbst(long &retval , long ** target, int* pe) {
        retval = nvshmem_ptrdiff_atomic_fetch(*target, *pe);
        return 0;
    }
        """


    _Z28nvshmem_ptrdiff_atomic_fetch_nbst = declare_device(
        '_Z28nvshmem_ptrdiff_atomic_fetch_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_ptrdiff_atomic_fetch_nbst_caller(arg_0, arg_1):
        return _Z28nvshmem_ptrdiff_atomic_fetch_nbst(arg_0, arg_1)
    

    @lower(ptrdiff_atomic_fetch, CPointer(int64), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_ptrdiff_atomic_fetch_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_ptrdiff_atomic_fetch_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_ptrdiff_atomic_fetch_nbst(shim_stream, shim_obj)


def int_atomic_set():
    pass
    

def _lower__Z22nvshmem_int_atomic_set_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmem_int_atomic_set_nbst(int &retval , int ** target, int* value, int* pe) {
        nvshmem_int_atomic_set(*target, *value, *pe);
        return 0;
    }
        """


    _Z22nvshmem_int_atomic_set_nbst = declare_device(
        '_Z22nvshmem_int_atomic_set_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmem_int_atomic_set_nbst_caller(arg_0, arg_1, arg_2):
        return _Z22nvshmem_int_atomic_set_nbst(arg_0, arg_1, arg_2)
    

    @lower(int_atomic_set, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmem_int_atomic_set_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmem_int_atomic_set_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmem_int_atomic_set_nbst(shim_stream, shim_obj)


def long_atomic_set():
    pass
    

def _lower__Z23nvshmem_long_atomic_set_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_long_atomic_set_nbst(int &retval , long ** target, long* value, int* pe) {
        nvshmem_long_atomic_set(*target, *value, *pe);
        return 0;
    }
        """


    _Z23nvshmem_long_atomic_set_nbst = declare_device(
        '_Z23nvshmem_long_atomic_set_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_long_atomic_set_nbst_caller(arg_0, arg_1, arg_2):
        return _Z23nvshmem_long_atomic_set_nbst(arg_0, arg_1, arg_2)
    

    @lower(long_atomic_set, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_long_atomic_set_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_long_atomic_set_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_long_atomic_set_nbst(shim_stream, shim_obj)


def longlong_atomic_set():
    pass
    

def _lower__Z27nvshmem_longlong_atomic_set_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmem_longlong_atomic_set_nbst(int &retval , long long ** target, long long* value, int* pe) {
        nvshmem_longlong_atomic_set(*target, *value, *pe);
        return 0;
    }
        """


    _Z27nvshmem_longlong_atomic_set_nbst = declare_device(
        '_Z27nvshmem_longlong_atomic_set_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z27nvshmem_longlong_atomic_set_nbst_caller(arg_0, arg_1, arg_2):
        return _Z27nvshmem_longlong_atomic_set_nbst(arg_0, arg_1, arg_2)
    

    @lower(longlong_atomic_set, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmem_longlong_atomic_set_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmem_longlong_atomic_set_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmem_longlong_atomic_set_nbst(shim_stream, shim_obj)


def uint_atomic_set():
    pass
    

def _lower__Z23nvshmem_uint_atomic_set_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_uint_atomic_set_nbst(int &retval , unsigned int ** target, unsigned int* value, int* pe) {
        nvshmem_uint_atomic_set(*target, *value, *pe);
        return 0;
    }
        """


    _Z23nvshmem_uint_atomic_set_nbst = declare_device(
        '_Z23nvshmem_uint_atomic_set_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_uint_atomic_set_nbst_caller(arg_0, arg_1, arg_2):
        return _Z23nvshmem_uint_atomic_set_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint_atomic_set, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_uint_atomic_set_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_uint_atomic_set_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_uint_atomic_set_nbst(shim_stream, shim_obj)


def ulong_atomic_set():
    pass
    

def _lower__Z24nvshmem_ulong_atomic_set_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_ulong_atomic_set_nbst(int &retval , unsigned long ** target, unsigned long* value, int* pe) {
        nvshmem_ulong_atomic_set(*target, *value, *pe);
        return 0;
    }
        """


    _Z24nvshmem_ulong_atomic_set_nbst = declare_device(
        '_Z24nvshmem_ulong_atomic_set_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_ulong_atomic_set_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_ulong_atomic_set_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulong_atomic_set, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_ulong_atomic_set_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_ulong_atomic_set_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_ulong_atomic_set_nbst(shim_stream, shim_obj)


def ulonglong_atomic_set():
    pass
    

def _lower__Z28nvshmem_ulonglong_atomic_set_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmem_ulonglong_atomic_set_nbst(int &retval , unsigned long long ** target, unsigned long long* value, int* pe) {
        nvshmem_ulonglong_atomic_set(*target, *value, *pe);
        return 0;
    }
        """


    _Z28nvshmem_ulonglong_atomic_set_nbst = declare_device(
        '_Z28nvshmem_ulonglong_atomic_set_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmem_ulonglong_atomic_set_nbst_caller(arg_0, arg_1, arg_2):
        return _Z28nvshmem_ulonglong_atomic_set_nbst(arg_0, arg_1, arg_2)
    

    @lower(ulonglong_atomic_set, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmem_ulonglong_atomic_set_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmem_ulonglong_atomic_set_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmem_ulonglong_atomic_set_nbst(shim_stream, shim_obj)


def int32_atomic_set():
    pass
    

def _lower__Z24nvshmem_int32_atomic_set_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_int32_atomic_set_nbst(int &retval , int32_t ** target, int32_t* value, int* pe) {
        nvshmem_int32_atomic_set(*target, *value, *pe);
        return 0;
    }
        """


    _Z24nvshmem_int32_atomic_set_nbst = declare_device(
        '_Z24nvshmem_int32_atomic_set_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_int32_atomic_set_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_int32_atomic_set_nbst(arg_0, arg_1, arg_2)
    

    @lower(int32_atomic_set, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_int32_atomic_set_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_int32_atomic_set_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_int32_atomic_set_nbst(shim_stream, shim_obj)


def int64_atomic_set():
    pass
    

def _lower__Z24nvshmem_int64_atomic_set_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_int64_atomic_set_nbst(int &retval , int64_t ** target, int64_t* value, int* pe) {
        nvshmem_int64_atomic_set(*target, *value, *pe);
        return 0;
    }
        """


    _Z24nvshmem_int64_atomic_set_nbst = declare_device(
        '_Z24nvshmem_int64_atomic_set_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_int64_atomic_set_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_int64_atomic_set_nbst(arg_0, arg_1, arg_2)
    

    @lower(int64_atomic_set, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_int64_atomic_set_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_int64_atomic_set_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_int64_atomic_set_nbst(shim_stream, shim_obj)


def uint32_atomic_set():
    pass
    

def _lower__Z25nvshmem_uint32_atomic_set_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_uint32_atomic_set_nbst(int &retval , uint32_t ** target, uint32_t* value, int* pe) {
        nvshmem_uint32_atomic_set(*target, *value, *pe);
        return 0;
    }
        """


    _Z25nvshmem_uint32_atomic_set_nbst = declare_device(
        '_Z25nvshmem_uint32_atomic_set_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_uint32_atomic_set_nbst_caller(arg_0, arg_1, arg_2):
        return _Z25nvshmem_uint32_atomic_set_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint32_atomic_set, CPointer(uint32), uint32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_uint32_atomic_set_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_uint32_atomic_set_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_uint32_atomic_set_nbst(shim_stream, shim_obj)


def uint64_atomic_set():
    pass
    

def _lower__Z25nvshmem_uint64_atomic_set_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_uint64_atomic_set_nbst(int &retval , uint64_t ** target, uint64_t* value, int* pe) {
        nvshmem_uint64_atomic_set(*target, *value, *pe);
        return 0;
    }
        """


    _Z25nvshmem_uint64_atomic_set_nbst = declare_device(
        '_Z25nvshmem_uint64_atomic_set_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_uint64_atomic_set_nbst_caller(arg_0, arg_1, arg_2):
        return _Z25nvshmem_uint64_atomic_set_nbst(arg_0, arg_1, arg_2)
    

    @lower(uint64_atomic_set, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_uint64_atomic_set_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_uint64_atomic_set_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_uint64_atomic_set_nbst(shim_stream, shim_obj)


def float_atomic_set():
    pass
    

def _lower__Z24nvshmem_float_atomic_set_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmem_float_atomic_set_nbst(int &retval , float ** target, float* value, int* pe) {
        nvshmem_float_atomic_set(*target, *value, *pe);
        return 0;
    }
        """


    _Z24nvshmem_float_atomic_set_nbst = declare_device(
        '_Z24nvshmem_float_atomic_set_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(float32), CPointer(int32)
        )
    )
    

    def _Z24nvshmem_float_atomic_set_nbst_caller(arg_0, arg_1, arg_2):
        return _Z24nvshmem_float_atomic_set_nbst(arg_0, arg_1, arg_2)
    

    @lower(float_atomic_set, CPointer(float32), float32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmem_float_atomic_set_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmem_float_atomic_set_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(float32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmem_float_atomic_set_nbst(shim_stream, shim_obj)


def double_atomic_set():
    pass
    

def _lower__Z25nvshmem_double_atomic_set_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmem_double_atomic_set_nbst(int &retval , double ** target, double* value, int* pe) {
        nvshmem_double_atomic_set(*target, *value, *pe);
        return 0;
    }
        """


    _Z25nvshmem_double_atomic_set_nbst = declare_device(
        '_Z25nvshmem_double_atomic_set_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(float64), CPointer(int32)
        )
    )
    

    def _Z25nvshmem_double_atomic_set_nbst_caller(arg_0, arg_1, arg_2):
        return _Z25nvshmem_double_atomic_set_nbst(arg_0, arg_1, arg_2)
    

    @lower(double_atomic_set, CPointer(float64), float64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmem_double_atomic_set_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmem_double_atomic_set_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(float64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmem_double_atomic_set_nbst(shim_stream, shim_obj)


def size_atomic_set():
    pass
    

def _lower__Z23nvshmem_size_atomic_set_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmem_size_atomic_set_nbst(int &retval , unsigned long ** target, unsigned long* value, int* pe) {
        nvshmem_size_atomic_set(*target, *value, *pe);
        return 0;
    }
        """


    _Z23nvshmem_size_atomic_set_nbst = declare_device(
        '_Z23nvshmem_size_atomic_set_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmem_size_atomic_set_nbst_caller(arg_0, arg_1, arg_2):
        return _Z23nvshmem_size_atomic_set_nbst(arg_0, arg_1, arg_2)
    

    @lower(size_atomic_set, CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmem_size_atomic_set_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmem_size_atomic_set_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmem_size_atomic_set_nbst(shim_stream, shim_obj)


def ptrdiff_atomic_set():
    pass
    

def _lower__Z26nvshmem_ptrdiff_atomic_set_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmem_ptrdiff_atomic_set_nbst(int &retval , long ** target, long* value, int* pe) {
        nvshmem_ptrdiff_atomic_set(*target, *value, *pe);
        return 0;
    }
        """


    _Z26nvshmem_ptrdiff_atomic_set_nbst = declare_device(
        '_Z26nvshmem_ptrdiff_atomic_set_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)
        )
    )
    

    def _Z26nvshmem_ptrdiff_atomic_set_nbst_caller(arg_0, arg_1, arg_2):
        return _Z26nvshmem_ptrdiff_atomic_set_nbst(arg_0, arg_1, arg_2)
    

    @lower(ptrdiff_atomic_set, CPointer(int64), int64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmem_ptrdiff_atomic_set_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmem_ptrdiff_atomic_set_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmem_ptrdiff_atomic_set_nbst(shim_stream, shim_obj)


def alltoallmem():
    pass
    

def _lower__ZL19nvshmem_alltoallmemiPvPKvm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL19nvshmem_alltoallmemiPvPKvm_nbst(int &retval , int* team, void ** dest, void ** source, unsigned long* nelems) {
        retval = nvshmem_alltoallmem(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL19nvshmem_alltoallmemiPvPKvm_nbst = declare_device(
        '_ZL19nvshmem_alltoallmemiPvPKvm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64)
        )
    )
    

    def _ZL19nvshmem_alltoallmemiPvPKvm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL19nvshmem_alltoallmemiPvPKvm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(alltoallmem, int32, CPointer(void), CPointer(void), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL19nvshmem_alltoallmemiPvPKvm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL19nvshmem_alltoallmemiPvPKvm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL19nvshmem_alltoallmemiPvPKvm_nbst(shim_stream, shim_obj)


def bfloat16_alltoall():
    pass
    

def _lower__ZL25nvshmem_bfloat16_alltoalliP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_bfloat16_alltoalliP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems) {
        retval = nvshmem_bfloat16_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL25nvshmem_bfloat16_alltoalliP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL25nvshmem_bfloat16_alltoalliP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_bfloat16_alltoalliP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_bfloat16_alltoalliP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_alltoall, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_bfloat16_alltoalliP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_bfloat16_alltoalliP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_bfloat16_alltoalliP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_alltoall():
    pass
    

def _lower__ZL21nvshmem_half_alltoalliP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL21nvshmem_half_alltoalliP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nelems) {
        retval = nvshmem_half_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL21nvshmem_half_alltoalliP6__halfPKS_m_nbst = declare_device(
        '_ZL21nvshmem_half_alltoalliP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL21nvshmem_half_alltoalliP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL21nvshmem_half_alltoalliP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_alltoall, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL21nvshmem_half_alltoalliP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL21nvshmem_half_alltoalliP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL21nvshmem_half_alltoalliP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_alltoall():
    pass
    

def _lower__ZL22nvshmem_float_alltoalliPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_float_alltoalliPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nelems) {
        retval = nvshmem_float_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL22nvshmem_float_alltoalliPfPKfm_nbst = declare_device(
        '_ZL22nvshmem_float_alltoalliPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_float_alltoalliPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_float_alltoalliPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_alltoall, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_float_alltoalliPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_float_alltoalliPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_float_alltoalliPfPKfm_nbst(shim_stream, shim_obj)


def double_alltoall():
    pass
    

def _lower__ZL23nvshmem_double_alltoalliPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_double_alltoalliPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nelems) {
        retval = nvshmem_double_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL23nvshmem_double_alltoalliPdPKdm_nbst = declare_device(
        '_ZL23nvshmem_double_alltoalliPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_double_alltoalliPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_double_alltoalliPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_alltoall, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_double_alltoalliPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_double_alltoalliPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_double_alltoalliPdPKdm_nbst(shim_stream, shim_obj)


def char_alltoall():
    pass
    

def _lower__ZL21nvshmem_char_alltoalliPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL21nvshmem_char_alltoalliPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nelems) {
        retval = nvshmem_char_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL21nvshmem_char_alltoalliPcPKcm_nbst = declare_device(
        '_ZL21nvshmem_char_alltoalliPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL21nvshmem_char_alltoalliPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL21nvshmem_char_alltoalliPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_alltoall, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL21nvshmem_char_alltoalliPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL21nvshmem_char_alltoalliPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL21nvshmem_char_alltoalliPcPKcm_nbst(shim_stream, shim_obj)


def short_alltoall():
    pass
    

def _lower__ZL22nvshmem_short_alltoalliPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_short_alltoalliPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nelems) {
        retval = nvshmem_short_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL22nvshmem_short_alltoalliPsPKsm_nbst = declare_device(
        '_ZL22nvshmem_short_alltoalliPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_short_alltoalliPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_short_alltoalliPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_alltoall, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_short_alltoalliPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_short_alltoalliPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_short_alltoalliPsPKsm_nbst(shim_stream, shim_obj)


def schar_alltoall():
    pass
    

def _lower__ZL22nvshmem_schar_alltoalliPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_schar_alltoalliPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nelems) {
        retval = nvshmem_schar_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL22nvshmem_schar_alltoalliPaPKam_nbst = declare_device(
        '_ZL22nvshmem_schar_alltoalliPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_schar_alltoalliPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_schar_alltoalliPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_alltoall, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_schar_alltoalliPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_schar_alltoalliPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_schar_alltoalliPaPKam_nbst(shim_stream, shim_obj)


def int_alltoall():
    pass
    

def _lower__ZL20nvshmem_int_alltoalliPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL20nvshmem_int_alltoalliPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nelems) {
        retval = nvshmem_int_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL20nvshmem_int_alltoalliPiPKim_nbst = declare_device(
        '_ZL20nvshmem_int_alltoalliPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL20nvshmem_int_alltoalliPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL20nvshmem_int_alltoalliPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_alltoall, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL20nvshmem_int_alltoalliPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL20nvshmem_int_alltoalliPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL20nvshmem_int_alltoalliPiPKim_nbst(shim_stream, shim_obj)


def long_alltoall():
    pass
    

def _lower__ZL21nvshmem_long_alltoalliPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL21nvshmem_long_alltoalliPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nelems) {
        retval = nvshmem_long_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL21nvshmem_long_alltoalliPlPKlm_nbst = declare_device(
        '_ZL21nvshmem_long_alltoalliPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL21nvshmem_long_alltoalliPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL21nvshmem_long_alltoalliPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_alltoall, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL21nvshmem_long_alltoalliPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL21nvshmem_long_alltoalliPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL21nvshmem_long_alltoalliPlPKlm_nbst(shim_stream, shim_obj)


def longlong_alltoall():
    pass
    

def _lower__ZL25nvshmem_longlong_alltoalliPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_longlong_alltoalliPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nelems) {
        retval = nvshmem_longlong_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL25nvshmem_longlong_alltoalliPxPKxm_nbst = declare_device(
        '_ZL25nvshmem_longlong_alltoalliPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_longlong_alltoalliPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_longlong_alltoalliPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_alltoall, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_longlong_alltoalliPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_longlong_alltoalliPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_longlong_alltoalliPxPKxm_nbst(shim_stream, shim_obj)


def uchar_alltoall():
    pass
    

def _lower__ZL22nvshmem_uchar_alltoalliPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_uchar_alltoalliPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nelems) {
        retval = nvshmem_uchar_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL22nvshmem_uchar_alltoalliPhPKhm_nbst = declare_device(
        '_ZL22nvshmem_uchar_alltoalliPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_uchar_alltoalliPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_uchar_alltoalliPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_alltoall, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_uchar_alltoalliPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_uchar_alltoalliPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_uchar_alltoalliPhPKhm_nbst(shim_stream, shim_obj)


def ushort_alltoall():
    pass
    

def _lower__ZL23nvshmem_ushort_alltoalliPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_ushort_alltoalliPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nelems) {
        retval = nvshmem_ushort_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL23nvshmem_ushort_alltoalliPtPKtm_nbst = declare_device(
        '_ZL23nvshmem_ushort_alltoalliPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_ushort_alltoalliPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_ushort_alltoalliPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_alltoall, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_ushort_alltoalliPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_ushort_alltoalliPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_ushort_alltoalliPtPKtm_nbst(shim_stream, shim_obj)


def uint_alltoall():
    pass
    

def _lower__ZL21nvshmem_uint_alltoalliPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL21nvshmem_uint_alltoalliPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nelems) {
        retval = nvshmem_uint_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL21nvshmem_uint_alltoalliPjPKjm_nbst = declare_device(
        '_ZL21nvshmem_uint_alltoalliPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL21nvshmem_uint_alltoalliPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL21nvshmem_uint_alltoalliPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_alltoall, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL21nvshmem_uint_alltoalliPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL21nvshmem_uint_alltoalliPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL21nvshmem_uint_alltoalliPjPKjm_nbst(shim_stream, shim_obj)


def ulong_alltoall():
    pass
    

def _lower__ZL22nvshmem_ulong_alltoalliPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_ulong_alltoalliPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nelems) {
        retval = nvshmem_ulong_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL22nvshmem_ulong_alltoalliPmPKmm_nbst = declare_device(
        '_ZL22nvshmem_ulong_alltoalliPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_ulong_alltoalliPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_ulong_alltoalliPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_alltoall, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_ulong_alltoalliPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_ulong_alltoalliPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_ulong_alltoalliPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_alltoall():
    pass
    

def _lower__ZL26nvshmem_ulonglong_alltoalliPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL26nvshmem_ulonglong_alltoalliPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems) {
        retval = nvshmem_ulonglong_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL26nvshmem_ulonglong_alltoalliPyPKym_nbst = declare_device(
        '_ZL26nvshmem_ulonglong_alltoalliPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL26nvshmem_ulonglong_alltoalliPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL26nvshmem_ulonglong_alltoalliPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_alltoall, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL26nvshmem_ulonglong_alltoalliPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL26nvshmem_ulonglong_alltoalliPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL26nvshmem_ulonglong_alltoalliPyPKym_nbst(shim_stream, shim_obj)


def int8_alltoall():
    pass
    

def _lower__ZL21nvshmem_int8_alltoalliPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL21nvshmem_int8_alltoalliPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nelems) {
        retval = nvshmem_int8_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL21nvshmem_int8_alltoalliPaPKam_nbst = declare_device(
        '_ZL21nvshmem_int8_alltoalliPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL21nvshmem_int8_alltoalliPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL21nvshmem_int8_alltoalliPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_alltoall, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL21nvshmem_int8_alltoalliPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL21nvshmem_int8_alltoalliPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL21nvshmem_int8_alltoalliPaPKam_nbst(shim_stream, shim_obj)


def int16_alltoall():
    pass
    

def _lower__ZL22nvshmem_int16_alltoalliPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_int16_alltoalliPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nelems) {
        retval = nvshmem_int16_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL22nvshmem_int16_alltoalliPsPKsm_nbst = declare_device(
        '_ZL22nvshmem_int16_alltoalliPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_int16_alltoalliPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_int16_alltoalliPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_alltoall, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_int16_alltoalliPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_int16_alltoalliPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_int16_alltoalliPsPKsm_nbst(shim_stream, shim_obj)


def int32_alltoall():
    pass
    

def _lower__ZL22nvshmem_int32_alltoalliPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_int32_alltoalliPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nelems) {
        retval = nvshmem_int32_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL22nvshmem_int32_alltoalliPiPKim_nbst = declare_device(
        '_ZL22nvshmem_int32_alltoalliPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_int32_alltoalliPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_int32_alltoalliPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_alltoall, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_int32_alltoalliPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_int32_alltoalliPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_int32_alltoalliPiPKim_nbst(shim_stream, shim_obj)


def int64_alltoall():
    pass
    

def _lower__ZL22nvshmem_int64_alltoalliPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_int64_alltoalliPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nelems) {
        retval = nvshmem_int64_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL22nvshmem_int64_alltoalliPlPKlm_nbst = declare_device(
        '_ZL22nvshmem_int64_alltoalliPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_int64_alltoalliPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_int64_alltoalliPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_alltoall, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_int64_alltoalliPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_int64_alltoalliPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_int64_alltoalliPlPKlm_nbst(shim_stream, shim_obj)


def uint8_alltoall():
    pass
    

def _lower__ZL22nvshmem_uint8_alltoalliPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_uint8_alltoalliPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nelems) {
        retval = nvshmem_uint8_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL22nvshmem_uint8_alltoalliPhPKhm_nbst = declare_device(
        '_ZL22nvshmem_uint8_alltoalliPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_uint8_alltoalliPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_uint8_alltoalliPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_alltoall, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_uint8_alltoalliPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_uint8_alltoalliPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_uint8_alltoalliPhPKhm_nbst(shim_stream, shim_obj)


def uint16_alltoall():
    pass
    

def _lower__ZL23nvshmem_uint16_alltoalliPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_uint16_alltoalliPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nelems) {
        retval = nvshmem_uint16_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL23nvshmem_uint16_alltoalliPtPKtm_nbst = declare_device(
        '_ZL23nvshmem_uint16_alltoalliPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_uint16_alltoalliPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_uint16_alltoalliPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_alltoall, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_uint16_alltoalliPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_uint16_alltoalliPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_uint16_alltoalliPtPKtm_nbst(shim_stream, shim_obj)


def uint32_alltoall():
    pass
    

def _lower__ZL23nvshmem_uint32_alltoalliPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_uint32_alltoalliPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nelems) {
        retval = nvshmem_uint32_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL23nvshmem_uint32_alltoalliPjPKjm_nbst = declare_device(
        '_ZL23nvshmem_uint32_alltoalliPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_uint32_alltoalliPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_uint32_alltoalliPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_alltoall, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_uint32_alltoalliPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_uint32_alltoalliPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_uint32_alltoalliPjPKjm_nbst(shim_stream, shim_obj)


def uint64_alltoall():
    pass
    

def _lower__ZL23nvshmem_uint64_alltoalliPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_uint64_alltoalliPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nelems) {
        retval = nvshmem_uint64_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL23nvshmem_uint64_alltoalliPmPKmm_nbst = declare_device(
        '_ZL23nvshmem_uint64_alltoalliPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_uint64_alltoalliPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_uint64_alltoalliPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_alltoall, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_uint64_alltoalliPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_uint64_alltoalliPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_uint64_alltoalliPmPKmm_nbst(shim_stream, shim_obj)


def size_alltoall():
    pass
    

def _lower__ZL21nvshmem_size_alltoalliPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL21nvshmem_size_alltoalliPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nelems) {
        retval = nvshmem_size_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL21nvshmem_size_alltoalliPmPKmm_nbst = declare_device(
        '_ZL21nvshmem_size_alltoalliPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL21nvshmem_size_alltoalliPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL21nvshmem_size_alltoalliPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_alltoall, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL21nvshmem_size_alltoalliPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL21nvshmem_size_alltoalliPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL21nvshmem_size_alltoalliPmPKmm_nbst(shim_stream, shim_obj)


def ptrdiff_alltoall():
    pass
    

def _lower__ZL24nvshmem_ptrdiff_alltoalliPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_ptrdiff_alltoalliPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nelems) {
        retval = nvshmem_ptrdiff_alltoall(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL24nvshmem_ptrdiff_alltoalliPlPKlm_nbst = declare_device(
        '_ZL24nvshmem_ptrdiff_alltoalliPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_ptrdiff_alltoalliPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_ptrdiff_alltoalliPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ptrdiff_alltoall, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_ptrdiff_alltoalliPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_ptrdiff_alltoalliPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_ptrdiff_alltoalliPlPKlm_nbst(shim_stream, shim_obj)


def barrier():
    pass
    

def _lower__ZL15nvshmem_barrieri_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL15nvshmem_barrieri_nbst(int &retval , int* team) {
        retval = nvshmem_barrier(*team);
        return 0;
    }
        """


    _ZL15nvshmem_barrieri_nbst = declare_device(
        '_ZL15nvshmem_barrieri_nbst',
        int32(
            CPointer(int32)
        )
    )
    

    def _ZL15nvshmem_barrieri_nbst_caller(arg_0):
        return _ZL15nvshmem_barrieri_nbst(arg_0)
    

    @lower(barrier, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL15nvshmem_barrieri_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL15nvshmem_barrieri_nbst_caller,
            signature(int32, CPointer(int32)),
            ptrs,
        )



_lower__ZL15nvshmem_barrieri_nbst(shim_stream, shim_obj)


def barrier_all():
    pass
    

def _lower__ZL19nvshmem_barrier_allv_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL19nvshmem_barrier_allv_nbst(int &retval ) {
        nvshmem_barrier_all();
        return 0;
    }
        """


    _ZL19nvshmem_barrier_allv_nbst = declare_device(
        '_ZL19nvshmem_barrier_allv_nbst',
        void(
        
        )
    )
    

    def _ZL19nvshmem_barrier_allv_nbst_caller():
        return _ZL19nvshmem_barrier_allv_nbst()
    

    @lower(barrier_all, )
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL19nvshmem_barrier_allv_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL19nvshmem_barrier_allv_nbst_caller,
            signature(void, ),
            ptrs,
        )



_lower__ZL19nvshmem_barrier_allv_nbst(shim_stream, shim_obj)


def team_sync():
    pass
    

def _lower__ZL17nvshmem_team_synci_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL17nvshmem_team_synci_nbst(int &retval , int* team) {
        retval = nvshmem_team_sync(*team);
        return 0;
    }
        """


    _ZL17nvshmem_team_synci_nbst = declare_device(
        '_ZL17nvshmem_team_synci_nbst',
        int32(
            CPointer(int32)
        )
    )
    

    def _ZL17nvshmem_team_synci_nbst_caller(arg_0):
        return _ZL17nvshmem_team_synci_nbst(arg_0)
    

    @lower(team_sync, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL17nvshmem_team_synci_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL17nvshmem_team_synci_nbst_caller,
            signature(int32, CPointer(int32)),
            ptrs,
        )



_lower__ZL17nvshmem_team_synci_nbst(shim_stream, shim_obj)


def sync_all():
    pass
    

def _lower__ZL16nvshmem_sync_allv_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL16nvshmem_sync_allv_nbst(int &retval ) {
        nvshmem_sync_all();
        return 0;
    }
        """


    _ZL16nvshmem_sync_allv_nbst = declare_device(
        '_ZL16nvshmem_sync_allv_nbst',
        void(
        
        )
    )
    

    def _ZL16nvshmem_sync_allv_nbst_caller():
        return _ZL16nvshmem_sync_allv_nbst()
    

    @lower(sync_all, )
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL16nvshmem_sync_allv_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL16nvshmem_sync_allv_nbst_caller,
            signature(void, ),
            ptrs,
        )



_lower__ZL16nvshmem_sync_allv_nbst(shim_stream, shim_obj)


def broadcastmem():
    pass
    

def _lower__ZL20nvshmem_broadcastmemiPvPKvmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL20nvshmem_broadcastmemiPvPKvmi_nbst(int &retval , int* team, void ** dest, void ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_broadcastmem(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL20nvshmem_broadcastmemiPvPKvmi_nbst = declare_device(
        '_ZL20nvshmem_broadcastmemiPvPKvmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL20nvshmem_broadcastmemiPvPKvmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL20nvshmem_broadcastmemiPvPKvmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(broadcastmem, int32, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL20nvshmem_broadcastmemiPvPKvmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL20nvshmem_broadcastmemiPvPKvmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL20nvshmem_broadcastmemiPvPKvmi_nbst(shim_stream, shim_obj)


def bfloat16_broadcast():
    pass
    

def _lower__ZL26nvshmem_bfloat16_broadcastiP13__nv_bfloat16PKS_mi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL26nvshmem_bfloat16_broadcastiP13__nv_bfloat16PKS_mi_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_bfloat16_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL26nvshmem_bfloat16_broadcastiP13__nv_bfloat16PKS_mi_nbst = declare_device(
        '_ZL26nvshmem_bfloat16_broadcastiP13__nv_bfloat16PKS_mi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL26nvshmem_bfloat16_broadcastiP13__nv_bfloat16PKS_mi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL26nvshmem_bfloat16_broadcastiP13__nv_bfloat16PKS_mi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(bfloat16_broadcast, int32, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL26nvshmem_bfloat16_broadcastiP13__nv_bfloat16PKS_mi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL26nvshmem_bfloat16_broadcastiP13__nv_bfloat16PKS_mi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL26nvshmem_bfloat16_broadcastiP13__nv_bfloat16PKS_mi_nbst(shim_stream, shim_obj)


def half_broadcast():
    pass
    

def _lower__ZL22nvshmem_half_broadcastiP6__halfPKS_mi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_half_broadcastiP6__halfPKS_mi_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_half_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL22nvshmem_half_broadcastiP6__halfPKS_mi_nbst = declare_device(
        '_ZL22nvshmem_half_broadcastiP6__halfPKS_mi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL22nvshmem_half_broadcastiP6__halfPKS_mi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL22nvshmem_half_broadcastiP6__halfPKS_mi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(half_broadcast, int32, CPointer(float16), CPointer(float16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_half_broadcastiP6__halfPKS_mi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_half_broadcastiP6__halfPKS_mi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL22nvshmem_half_broadcastiP6__halfPKS_mi_nbst(shim_stream, shim_obj)


def float_broadcast():
    pass
    

def _lower__ZL23nvshmem_float_broadcastiPfPKfmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_float_broadcastiPfPKfmi_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_float_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL23nvshmem_float_broadcastiPfPKfmi_nbst = declare_device(
        '_ZL23nvshmem_float_broadcastiPfPKfmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL23nvshmem_float_broadcastiPfPKfmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL23nvshmem_float_broadcastiPfPKfmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(float_broadcast, int32, CPointer(float32), CPointer(float32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_float_broadcastiPfPKfmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_float_broadcastiPfPKfmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL23nvshmem_float_broadcastiPfPKfmi_nbst(shim_stream, shim_obj)


def double_broadcast():
    pass
    

def _lower__ZL24nvshmem_double_broadcastiPdPKdmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_double_broadcastiPdPKdmi_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_double_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL24nvshmem_double_broadcastiPdPKdmi_nbst = declare_device(
        '_ZL24nvshmem_double_broadcastiPdPKdmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL24nvshmem_double_broadcastiPdPKdmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL24nvshmem_double_broadcastiPdPKdmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(double_broadcast, int32, CPointer(float64), CPointer(float64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_double_broadcastiPdPKdmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_double_broadcastiPdPKdmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL24nvshmem_double_broadcastiPdPKdmi_nbst(shim_stream, shim_obj)


def char_broadcast():
    pass
    

def _lower__ZL22nvshmem_char_broadcastiPcPKcmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_char_broadcastiPcPKcmi_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_char_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL22nvshmem_char_broadcastiPcPKcmi_nbst = declare_device(
        '_ZL22nvshmem_char_broadcastiPcPKcmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL22nvshmem_char_broadcastiPcPKcmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL22nvshmem_char_broadcastiPcPKcmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(char_broadcast, int32, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_char_broadcastiPcPKcmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_char_broadcastiPcPKcmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL22nvshmem_char_broadcastiPcPKcmi_nbst(shim_stream, shim_obj)


def short_broadcast():
    pass
    

def _lower__ZL23nvshmem_short_broadcastiPsPKsmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_short_broadcastiPsPKsmi_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_short_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL23nvshmem_short_broadcastiPsPKsmi_nbst = declare_device(
        '_ZL23nvshmem_short_broadcastiPsPKsmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL23nvshmem_short_broadcastiPsPKsmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL23nvshmem_short_broadcastiPsPKsmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(short_broadcast, int32, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_short_broadcastiPsPKsmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_short_broadcastiPsPKsmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL23nvshmem_short_broadcastiPsPKsmi_nbst(shim_stream, shim_obj)


def schar_broadcast():
    pass
    

def _lower__ZL23nvshmem_schar_broadcastiPaPKami_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_schar_broadcastiPaPKami_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_schar_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL23nvshmem_schar_broadcastiPaPKami_nbst = declare_device(
        '_ZL23nvshmem_schar_broadcastiPaPKami_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL23nvshmem_schar_broadcastiPaPKami_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL23nvshmem_schar_broadcastiPaPKami_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(schar_broadcast, int32, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_schar_broadcastiPaPKami_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_schar_broadcastiPaPKami_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL23nvshmem_schar_broadcastiPaPKami_nbst(shim_stream, shim_obj)


def int_broadcast():
    pass
    

def _lower__ZL21nvshmem_int_broadcastiPiPKimi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL21nvshmem_int_broadcastiPiPKimi_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_int_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL21nvshmem_int_broadcastiPiPKimi_nbst = declare_device(
        '_ZL21nvshmem_int_broadcastiPiPKimi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL21nvshmem_int_broadcastiPiPKimi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL21nvshmem_int_broadcastiPiPKimi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int_broadcast, int32, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL21nvshmem_int_broadcastiPiPKimi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL21nvshmem_int_broadcastiPiPKimi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL21nvshmem_int_broadcastiPiPKimi_nbst(shim_stream, shim_obj)


def long_broadcast():
    pass
    

def _lower__ZL22nvshmem_long_broadcastiPlPKlmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_long_broadcastiPlPKlmi_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_long_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL22nvshmem_long_broadcastiPlPKlmi_nbst = declare_device(
        '_ZL22nvshmem_long_broadcastiPlPKlmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL22nvshmem_long_broadcastiPlPKlmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL22nvshmem_long_broadcastiPlPKlmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(long_broadcast, int32, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_long_broadcastiPlPKlmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_long_broadcastiPlPKlmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL22nvshmem_long_broadcastiPlPKlmi_nbst(shim_stream, shim_obj)


def longlong_broadcast():
    pass
    

def _lower__ZL26nvshmem_longlong_broadcastiPxPKxmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL26nvshmem_longlong_broadcastiPxPKxmi_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_longlong_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL26nvshmem_longlong_broadcastiPxPKxmi_nbst = declare_device(
        '_ZL26nvshmem_longlong_broadcastiPxPKxmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL26nvshmem_longlong_broadcastiPxPKxmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL26nvshmem_longlong_broadcastiPxPKxmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(longlong_broadcast, int32, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL26nvshmem_longlong_broadcastiPxPKxmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL26nvshmem_longlong_broadcastiPxPKxmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL26nvshmem_longlong_broadcastiPxPKxmi_nbst(shim_stream, shim_obj)


def uchar_broadcast():
    pass
    

def _lower__ZL23nvshmem_uchar_broadcastiPhPKhmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_uchar_broadcastiPhPKhmi_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_uchar_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL23nvshmem_uchar_broadcastiPhPKhmi_nbst = declare_device(
        '_ZL23nvshmem_uchar_broadcastiPhPKhmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL23nvshmem_uchar_broadcastiPhPKhmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL23nvshmem_uchar_broadcastiPhPKhmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uchar_broadcast, int32, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_uchar_broadcastiPhPKhmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_uchar_broadcastiPhPKhmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL23nvshmem_uchar_broadcastiPhPKhmi_nbst(shim_stream, shim_obj)


def ushort_broadcast():
    pass
    

def _lower__ZL24nvshmem_ushort_broadcastiPtPKtmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_ushort_broadcastiPtPKtmi_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_ushort_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL24nvshmem_ushort_broadcastiPtPKtmi_nbst = declare_device(
        '_ZL24nvshmem_ushort_broadcastiPtPKtmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL24nvshmem_ushort_broadcastiPtPKtmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL24nvshmem_ushort_broadcastiPtPKtmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ushort_broadcast, int32, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_ushort_broadcastiPtPKtmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_ushort_broadcastiPtPKtmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL24nvshmem_ushort_broadcastiPtPKtmi_nbst(shim_stream, shim_obj)


def uint_broadcast():
    pass
    

def _lower__ZL22nvshmem_uint_broadcastiPjPKjmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_uint_broadcastiPjPKjmi_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_uint_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL22nvshmem_uint_broadcastiPjPKjmi_nbst = declare_device(
        '_ZL22nvshmem_uint_broadcastiPjPKjmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL22nvshmem_uint_broadcastiPjPKjmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL22nvshmem_uint_broadcastiPjPKjmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint_broadcast, int32, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_uint_broadcastiPjPKjmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_uint_broadcastiPjPKjmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL22nvshmem_uint_broadcastiPjPKjmi_nbst(shim_stream, shim_obj)


def ulong_broadcast():
    pass
    

def _lower__ZL23nvshmem_ulong_broadcastiPmPKmmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_ulong_broadcastiPmPKmmi_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_ulong_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL23nvshmem_ulong_broadcastiPmPKmmi_nbst = declare_device(
        '_ZL23nvshmem_ulong_broadcastiPmPKmmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL23nvshmem_ulong_broadcastiPmPKmmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL23nvshmem_ulong_broadcastiPmPKmmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulong_broadcast, int32, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_ulong_broadcastiPmPKmmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_ulong_broadcastiPmPKmmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL23nvshmem_ulong_broadcastiPmPKmmi_nbst(shim_stream, shim_obj)


def ulonglong_broadcast():
    pass
    

def _lower__ZL27nvshmem_ulonglong_broadcastiPyPKymi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmem_ulonglong_broadcastiPyPKymi_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_ulonglong_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL27nvshmem_ulonglong_broadcastiPyPKymi_nbst = declare_device(
        '_ZL27nvshmem_ulonglong_broadcastiPyPKymi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL27nvshmem_ulonglong_broadcastiPyPKymi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL27nvshmem_ulonglong_broadcastiPyPKymi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulonglong_broadcast, int32, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmem_ulonglong_broadcastiPyPKymi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmem_ulonglong_broadcastiPyPKymi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL27nvshmem_ulonglong_broadcastiPyPKymi_nbst(shim_stream, shim_obj)


def int8_broadcast():
    pass
    

def _lower__ZL22nvshmem_int8_broadcastiPaPKami_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_int8_broadcastiPaPKami_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_int8_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL22nvshmem_int8_broadcastiPaPKami_nbst = declare_device(
        '_ZL22nvshmem_int8_broadcastiPaPKami_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL22nvshmem_int8_broadcastiPaPKami_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL22nvshmem_int8_broadcastiPaPKami_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int8_broadcast, int32, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_int8_broadcastiPaPKami_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_int8_broadcastiPaPKami_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL22nvshmem_int8_broadcastiPaPKami_nbst(shim_stream, shim_obj)


def int16_broadcast():
    pass
    

def _lower__ZL23nvshmem_int16_broadcastiPsPKsmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_int16_broadcastiPsPKsmi_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_int16_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL23nvshmem_int16_broadcastiPsPKsmi_nbst = declare_device(
        '_ZL23nvshmem_int16_broadcastiPsPKsmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL23nvshmem_int16_broadcastiPsPKsmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL23nvshmem_int16_broadcastiPsPKsmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int16_broadcast, int32, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_int16_broadcastiPsPKsmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_int16_broadcastiPsPKsmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL23nvshmem_int16_broadcastiPsPKsmi_nbst(shim_stream, shim_obj)


def int32_broadcast():
    pass
    

def _lower__ZL23nvshmem_int32_broadcastiPiPKimi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_int32_broadcastiPiPKimi_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_int32_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL23nvshmem_int32_broadcastiPiPKimi_nbst = declare_device(
        '_ZL23nvshmem_int32_broadcastiPiPKimi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL23nvshmem_int32_broadcastiPiPKimi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL23nvshmem_int32_broadcastiPiPKimi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int32_broadcast, int32, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_int32_broadcastiPiPKimi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_int32_broadcastiPiPKimi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL23nvshmem_int32_broadcastiPiPKimi_nbst(shim_stream, shim_obj)


def int64_broadcast():
    pass
    

def _lower__ZL23nvshmem_int64_broadcastiPlPKlmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_int64_broadcastiPlPKlmi_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_int64_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL23nvshmem_int64_broadcastiPlPKlmi_nbst = declare_device(
        '_ZL23nvshmem_int64_broadcastiPlPKlmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL23nvshmem_int64_broadcastiPlPKlmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL23nvshmem_int64_broadcastiPlPKlmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int64_broadcast, int32, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_int64_broadcastiPlPKlmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_int64_broadcastiPlPKlmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL23nvshmem_int64_broadcastiPlPKlmi_nbst(shim_stream, shim_obj)


def uint8_broadcast():
    pass
    

def _lower__ZL23nvshmem_uint8_broadcastiPhPKhmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_uint8_broadcastiPhPKhmi_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_uint8_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL23nvshmem_uint8_broadcastiPhPKhmi_nbst = declare_device(
        '_ZL23nvshmem_uint8_broadcastiPhPKhmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL23nvshmem_uint8_broadcastiPhPKhmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL23nvshmem_uint8_broadcastiPhPKhmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint8_broadcast, int32, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_uint8_broadcastiPhPKhmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_uint8_broadcastiPhPKhmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL23nvshmem_uint8_broadcastiPhPKhmi_nbst(shim_stream, shim_obj)


def uint16_broadcast():
    pass
    

def _lower__ZL24nvshmem_uint16_broadcastiPtPKtmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_uint16_broadcastiPtPKtmi_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_uint16_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL24nvshmem_uint16_broadcastiPtPKtmi_nbst = declare_device(
        '_ZL24nvshmem_uint16_broadcastiPtPKtmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL24nvshmem_uint16_broadcastiPtPKtmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL24nvshmem_uint16_broadcastiPtPKtmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint16_broadcast, int32, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_uint16_broadcastiPtPKtmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_uint16_broadcastiPtPKtmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL24nvshmem_uint16_broadcastiPtPKtmi_nbst(shim_stream, shim_obj)


def uint32_broadcast():
    pass
    

def _lower__ZL24nvshmem_uint32_broadcastiPjPKjmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_uint32_broadcastiPjPKjmi_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_uint32_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL24nvshmem_uint32_broadcastiPjPKjmi_nbst = declare_device(
        '_ZL24nvshmem_uint32_broadcastiPjPKjmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL24nvshmem_uint32_broadcastiPjPKjmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL24nvshmem_uint32_broadcastiPjPKjmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint32_broadcast, int32, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_uint32_broadcastiPjPKjmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_uint32_broadcastiPjPKjmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL24nvshmem_uint32_broadcastiPjPKjmi_nbst(shim_stream, shim_obj)


def uint64_broadcast():
    pass
    

def _lower__ZL24nvshmem_uint64_broadcastiPmPKmmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_uint64_broadcastiPmPKmmi_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_uint64_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL24nvshmem_uint64_broadcastiPmPKmmi_nbst = declare_device(
        '_ZL24nvshmem_uint64_broadcastiPmPKmmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL24nvshmem_uint64_broadcastiPmPKmmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL24nvshmem_uint64_broadcastiPmPKmmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint64_broadcast, int32, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_uint64_broadcastiPmPKmmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_uint64_broadcastiPmPKmmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL24nvshmem_uint64_broadcastiPmPKmmi_nbst(shim_stream, shim_obj)


def size_broadcast():
    pass
    

def _lower__ZL22nvshmem_size_broadcastiPmPKmmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_size_broadcastiPmPKmmi_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_size_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL22nvshmem_size_broadcastiPmPKmmi_nbst = declare_device(
        '_ZL22nvshmem_size_broadcastiPmPKmmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL22nvshmem_size_broadcastiPmPKmmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL22nvshmem_size_broadcastiPmPKmmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(size_broadcast, int32, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_size_broadcastiPmPKmmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_size_broadcastiPmPKmmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL22nvshmem_size_broadcastiPmPKmmi_nbst(shim_stream, shim_obj)


def ptrdiff_broadcast():
    pass
    

def _lower__ZL25nvshmem_ptrdiff_broadcastiPlPKlmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_ptrdiff_broadcastiPlPKlmi_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmem_ptrdiff_broadcast(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL25nvshmem_ptrdiff_broadcastiPlPKlmi_nbst = declare_device(
        '_ZL25nvshmem_ptrdiff_broadcastiPlPKlmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL25nvshmem_ptrdiff_broadcastiPlPKlmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL25nvshmem_ptrdiff_broadcastiPlPKlmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ptrdiff_broadcast, int32, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_ptrdiff_broadcastiPlPKlmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_ptrdiff_broadcastiPlPKlmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL25nvshmem_ptrdiff_broadcastiPlPKlmi_nbst(shim_stream, shim_obj)


def fcollectmem():
    pass
    

def _lower__ZL19nvshmem_fcollectmemiPvPKvm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL19nvshmem_fcollectmemiPvPKvm_nbst(int &retval , int* team, void ** dest, void ** source, unsigned long* nelems) {
        retval = nvshmem_fcollectmem(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL19nvshmem_fcollectmemiPvPKvm_nbst = declare_device(
        '_ZL19nvshmem_fcollectmemiPvPKvm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64)
        )
    )
    

    def _ZL19nvshmem_fcollectmemiPvPKvm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL19nvshmem_fcollectmemiPvPKvm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(fcollectmem, int32, CPointer(void), CPointer(void), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL19nvshmem_fcollectmemiPvPKvm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL19nvshmem_fcollectmemiPvPKvm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL19nvshmem_fcollectmemiPvPKvm_nbst(shim_stream, shim_obj)


def bfloat16_fcollect():
    pass
    

def _lower__ZL25nvshmem_bfloat16_fcollectiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_bfloat16_fcollectiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems) {
        retval = nvshmem_bfloat16_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL25nvshmem_bfloat16_fcollectiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL25nvshmem_bfloat16_fcollectiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_bfloat16_fcollectiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_bfloat16_fcollectiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_fcollect, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_bfloat16_fcollectiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_bfloat16_fcollectiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_bfloat16_fcollectiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_fcollect():
    pass
    

def _lower__ZL21nvshmem_half_fcollectiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL21nvshmem_half_fcollectiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nelems) {
        retval = nvshmem_half_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL21nvshmem_half_fcollectiP6__halfPKS_m_nbst = declare_device(
        '_ZL21nvshmem_half_fcollectiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL21nvshmem_half_fcollectiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL21nvshmem_half_fcollectiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_fcollect, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL21nvshmem_half_fcollectiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL21nvshmem_half_fcollectiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL21nvshmem_half_fcollectiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_fcollect():
    pass
    

def _lower__ZL22nvshmem_float_fcollectiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_float_fcollectiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nelems) {
        retval = nvshmem_float_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL22nvshmem_float_fcollectiPfPKfm_nbst = declare_device(
        '_ZL22nvshmem_float_fcollectiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_float_fcollectiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_float_fcollectiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_fcollect, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_float_fcollectiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_float_fcollectiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_float_fcollectiPfPKfm_nbst(shim_stream, shim_obj)


def double_fcollect():
    pass
    

def _lower__ZL23nvshmem_double_fcollectiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_double_fcollectiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nelems) {
        retval = nvshmem_double_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL23nvshmem_double_fcollectiPdPKdm_nbst = declare_device(
        '_ZL23nvshmem_double_fcollectiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_double_fcollectiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_double_fcollectiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_fcollect, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_double_fcollectiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_double_fcollectiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_double_fcollectiPdPKdm_nbst(shim_stream, shim_obj)


def char_fcollect():
    pass
    

def _lower__ZL21nvshmem_char_fcollectiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL21nvshmem_char_fcollectiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nelems) {
        retval = nvshmem_char_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL21nvshmem_char_fcollectiPcPKcm_nbst = declare_device(
        '_ZL21nvshmem_char_fcollectiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL21nvshmem_char_fcollectiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL21nvshmem_char_fcollectiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_fcollect, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL21nvshmem_char_fcollectiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL21nvshmem_char_fcollectiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL21nvshmem_char_fcollectiPcPKcm_nbst(shim_stream, shim_obj)


def short_fcollect():
    pass
    

def _lower__ZL22nvshmem_short_fcollectiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_short_fcollectiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nelems) {
        retval = nvshmem_short_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL22nvshmem_short_fcollectiPsPKsm_nbst = declare_device(
        '_ZL22nvshmem_short_fcollectiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_short_fcollectiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_short_fcollectiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_fcollect, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_short_fcollectiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_short_fcollectiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_short_fcollectiPsPKsm_nbst(shim_stream, shim_obj)


def schar_fcollect():
    pass
    

def _lower__ZL22nvshmem_schar_fcollectiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_schar_fcollectiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nelems) {
        retval = nvshmem_schar_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL22nvshmem_schar_fcollectiPaPKam_nbst = declare_device(
        '_ZL22nvshmem_schar_fcollectiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_schar_fcollectiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_schar_fcollectiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_fcollect, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_schar_fcollectiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_schar_fcollectiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_schar_fcollectiPaPKam_nbst(shim_stream, shim_obj)


def int_fcollect():
    pass
    

def _lower__ZL20nvshmem_int_fcollectiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL20nvshmem_int_fcollectiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nelems) {
        retval = nvshmem_int_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL20nvshmem_int_fcollectiPiPKim_nbst = declare_device(
        '_ZL20nvshmem_int_fcollectiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL20nvshmem_int_fcollectiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL20nvshmem_int_fcollectiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_fcollect, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL20nvshmem_int_fcollectiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL20nvshmem_int_fcollectiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL20nvshmem_int_fcollectiPiPKim_nbst(shim_stream, shim_obj)


def long_fcollect():
    pass
    

def _lower__ZL21nvshmem_long_fcollectiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL21nvshmem_long_fcollectiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nelems) {
        retval = nvshmem_long_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL21nvshmem_long_fcollectiPlPKlm_nbst = declare_device(
        '_ZL21nvshmem_long_fcollectiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL21nvshmem_long_fcollectiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL21nvshmem_long_fcollectiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_fcollect, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL21nvshmem_long_fcollectiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL21nvshmem_long_fcollectiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL21nvshmem_long_fcollectiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_fcollect():
    pass
    

def _lower__ZL25nvshmem_longlong_fcollectiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_longlong_fcollectiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nelems) {
        retval = nvshmem_longlong_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL25nvshmem_longlong_fcollectiPxPKxm_nbst = declare_device(
        '_ZL25nvshmem_longlong_fcollectiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_longlong_fcollectiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_longlong_fcollectiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_fcollect, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_longlong_fcollectiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_longlong_fcollectiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_longlong_fcollectiPxPKxm_nbst(shim_stream, shim_obj)


def uchar_fcollect():
    pass
    

def _lower__ZL22nvshmem_uchar_fcollectiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_uchar_fcollectiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nelems) {
        retval = nvshmem_uchar_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL22nvshmem_uchar_fcollectiPhPKhm_nbst = declare_device(
        '_ZL22nvshmem_uchar_fcollectiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_uchar_fcollectiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_uchar_fcollectiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_fcollect, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_uchar_fcollectiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_uchar_fcollectiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_uchar_fcollectiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_fcollect():
    pass
    

def _lower__ZL23nvshmem_ushort_fcollectiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_ushort_fcollectiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nelems) {
        retval = nvshmem_ushort_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL23nvshmem_ushort_fcollectiPtPKtm_nbst = declare_device(
        '_ZL23nvshmem_ushort_fcollectiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_ushort_fcollectiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_ushort_fcollectiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_fcollect, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_ushort_fcollectiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_ushort_fcollectiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_ushort_fcollectiPtPKtm_nbst(shim_stream, shim_obj)


def uint_fcollect():
    pass
    

def _lower__ZL21nvshmem_uint_fcollectiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL21nvshmem_uint_fcollectiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nelems) {
        retval = nvshmem_uint_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL21nvshmem_uint_fcollectiPjPKjm_nbst = declare_device(
        '_ZL21nvshmem_uint_fcollectiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL21nvshmem_uint_fcollectiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL21nvshmem_uint_fcollectiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_fcollect, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL21nvshmem_uint_fcollectiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL21nvshmem_uint_fcollectiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL21nvshmem_uint_fcollectiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_fcollect():
    pass
    

def _lower__ZL22nvshmem_ulong_fcollectiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_ulong_fcollectiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nelems) {
        retval = nvshmem_ulong_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL22nvshmem_ulong_fcollectiPmPKmm_nbst = declare_device(
        '_ZL22nvshmem_ulong_fcollectiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_ulong_fcollectiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_ulong_fcollectiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_fcollect, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_ulong_fcollectiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_ulong_fcollectiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_ulong_fcollectiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_fcollect():
    pass
    

def _lower__ZL26nvshmem_ulonglong_fcollectiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL26nvshmem_ulonglong_fcollectiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems) {
        retval = nvshmem_ulonglong_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL26nvshmem_ulonglong_fcollectiPyPKym_nbst = declare_device(
        '_ZL26nvshmem_ulonglong_fcollectiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL26nvshmem_ulonglong_fcollectiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL26nvshmem_ulonglong_fcollectiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_fcollect, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL26nvshmem_ulonglong_fcollectiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL26nvshmem_ulonglong_fcollectiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL26nvshmem_ulonglong_fcollectiPyPKym_nbst(shim_stream, shim_obj)


def int8_fcollect():
    pass
    

def _lower__ZL21nvshmem_int8_fcollectiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL21nvshmem_int8_fcollectiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nelems) {
        retval = nvshmem_int8_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL21nvshmem_int8_fcollectiPaPKam_nbst = declare_device(
        '_ZL21nvshmem_int8_fcollectiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL21nvshmem_int8_fcollectiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL21nvshmem_int8_fcollectiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_fcollect, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL21nvshmem_int8_fcollectiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL21nvshmem_int8_fcollectiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL21nvshmem_int8_fcollectiPaPKam_nbst(shim_stream, shim_obj)


def int16_fcollect():
    pass
    

def _lower__ZL22nvshmem_int16_fcollectiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_int16_fcollectiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nelems) {
        retval = nvshmem_int16_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL22nvshmem_int16_fcollectiPsPKsm_nbst = declare_device(
        '_ZL22nvshmem_int16_fcollectiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_int16_fcollectiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_int16_fcollectiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_fcollect, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_int16_fcollectiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_int16_fcollectiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_int16_fcollectiPsPKsm_nbst(shim_stream, shim_obj)


def int32_fcollect():
    pass
    

def _lower__ZL22nvshmem_int32_fcollectiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_int32_fcollectiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nelems) {
        retval = nvshmem_int32_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL22nvshmem_int32_fcollectiPiPKim_nbst = declare_device(
        '_ZL22nvshmem_int32_fcollectiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_int32_fcollectiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_int32_fcollectiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_fcollect, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_int32_fcollectiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_int32_fcollectiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_int32_fcollectiPiPKim_nbst(shim_stream, shim_obj)


def int64_fcollect():
    pass
    

def _lower__ZL22nvshmem_int64_fcollectiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_int64_fcollectiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nelems) {
        retval = nvshmem_int64_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL22nvshmem_int64_fcollectiPlPKlm_nbst = declare_device(
        '_ZL22nvshmem_int64_fcollectiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_int64_fcollectiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_int64_fcollectiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_fcollect, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_int64_fcollectiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_int64_fcollectiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_int64_fcollectiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_fcollect():
    pass
    

def _lower__ZL22nvshmem_uint8_fcollectiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_uint8_fcollectiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nelems) {
        retval = nvshmem_uint8_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL22nvshmem_uint8_fcollectiPhPKhm_nbst = declare_device(
        '_ZL22nvshmem_uint8_fcollectiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_uint8_fcollectiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_uint8_fcollectiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_fcollect, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_uint8_fcollectiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_uint8_fcollectiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_uint8_fcollectiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_fcollect():
    pass
    

def _lower__ZL23nvshmem_uint16_fcollectiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_uint16_fcollectiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nelems) {
        retval = nvshmem_uint16_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL23nvshmem_uint16_fcollectiPtPKtm_nbst = declare_device(
        '_ZL23nvshmem_uint16_fcollectiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_uint16_fcollectiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_uint16_fcollectiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_fcollect, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_uint16_fcollectiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_uint16_fcollectiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_uint16_fcollectiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_fcollect():
    pass
    

def _lower__ZL23nvshmem_uint32_fcollectiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_uint32_fcollectiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nelems) {
        retval = nvshmem_uint32_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL23nvshmem_uint32_fcollectiPjPKjm_nbst = declare_device(
        '_ZL23nvshmem_uint32_fcollectiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_uint32_fcollectiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_uint32_fcollectiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_fcollect, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_uint32_fcollectiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_uint32_fcollectiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_uint32_fcollectiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_fcollect():
    pass
    

def _lower__ZL23nvshmem_uint64_fcollectiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_uint64_fcollectiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nelems) {
        retval = nvshmem_uint64_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL23nvshmem_uint64_fcollectiPmPKmm_nbst = declare_device(
        '_ZL23nvshmem_uint64_fcollectiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_uint64_fcollectiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_uint64_fcollectiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_fcollect, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_uint64_fcollectiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_uint64_fcollectiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_uint64_fcollectiPmPKmm_nbst(shim_stream, shim_obj)


def size_fcollect():
    pass
    

def _lower__ZL21nvshmem_size_fcollectiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL21nvshmem_size_fcollectiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nelems) {
        retval = nvshmem_size_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL21nvshmem_size_fcollectiPmPKmm_nbst = declare_device(
        '_ZL21nvshmem_size_fcollectiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL21nvshmem_size_fcollectiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL21nvshmem_size_fcollectiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_fcollect, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL21nvshmem_size_fcollectiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL21nvshmem_size_fcollectiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL21nvshmem_size_fcollectiPmPKmm_nbst(shim_stream, shim_obj)


def ptrdiff_fcollect():
    pass
    

def _lower__ZL24nvshmem_ptrdiff_fcollectiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_ptrdiff_fcollectiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nelems) {
        retval = nvshmem_ptrdiff_fcollect(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL24nvshmem_ptrdiff_fcollectiPlPKlm_nbst = declare_device(
        '_ZL24nvshmem_ptrdiff_fcollectiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_ptrdiff_fcollectiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_ptrdiff_fcollectiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ptrdiff_fcollect, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_ptrdiff_fcollectiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_ptrdiff_fcollectiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_ptrdiff_fcollectiPlPKlm_nbst(shim_stream, shim_obj)


def uchar_and_reduce():
    pass
    

def _lower__ZL24nvshmem_uchar_and_reduceiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_uchar_and_reduceiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmem_uchar_and_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_uchar_and_reduceiPhPKhm_nbst = declare_device(
        '_ZL24nvshmem_uchar_and_reduceiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_uchar_and_reduceiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_uchar_and_reduceiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_and_reduce, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_uchar_and_reduceiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_uchar_and_reduceiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_uchar_and_reduceiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_and_reduce():
    pass
    

def _lower__ZL25nvshmem_ushort_and_reduceiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_ushort_and_reduceiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmem_ushort_and_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_ushort_and_reduceiPtPKtm_nbst = declare_device(
        '_ZL25nvshmem_ushort_and_reduceiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_ushort_and_reduceiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_ushort_and_reduceiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_and_reduce, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_ushort_and_reduceiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_ushort_and_reduceiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_ushort_and_reduceiPtPKtm_nbst(shim_stream, shim_obj)


def uint_and_reduce():
    pass
    

def _lower__ZL23nvshmem_uint_and_reduceiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_uint_and_reduceiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmem_uint_and_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_uint_and_reduceiPjPKjm_nbst = declare_device(
        '_ZL23nvshmem_uint_and_reduceiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_uint_and_reduceiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_uint_and_reduceiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_and_reduce, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_uint_and_reduceiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_uint_and_reduceiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_uint_and_reduceiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_and_reduce():
    pass
    

def _lower__ZL24nvshmem_ulong_and_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_ulong_and_reduceiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulong_and_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_ulong_and_reduceiPmPKmm_nbst = declare_device(
        '_ZL24nvshmem_ulong_and_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_ulong_and_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_ulong_and_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_and_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_ulong_and_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_ulong_and_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_ulong_and_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_and_reduce():
    pass
    

def _lower__ZL28nvshmem_ulonglong_and_reduceiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmem_ulonglong_and_reduceiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulonglong_and_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL28nvshmem_ulonglong_and_reduceiPyPKym_nbst = declare_device(
        '_ZL28nvshmem_ulonglong_and_reduceiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmem_ulonglong_and_reduceiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmem_ulonglong_and_reduceiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_and_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmem_ulonglong_and_reduceiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmem_ulonglong_and_reduceiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmem_ulonglong_and_reduceiPyPKym_nbst(shim_stream, shim_obj)


def int8_and_reduce():
    pass
    

def _lower__ZL23nvshmem_int8_and_reduceiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_int8_and_reduceiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int8_and_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_int8_and_reduceiPaPKam_nbst = declare_device(
        '_ZL23nvshmem_int8_and_reduceiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_int8_and_reduceiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_int8_and_reduceiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_and_reduce, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_int8_and_reduceiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_int8_and_reduceiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_int8_and_reduceiPaPKam_nbst(shim_stream, shim_obj)


def int16_and_reduce():
    pass
    

def _lower__ZL24nvshmem_int16_and_reduceiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_int16_and_reduceiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int16_and_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_int16_and_reduceiPsPKsm_nbst = declare_device(
        '_ZL24nvshmem_int16_and_reduceiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_int16_and_reduceiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_int16_and_reduceiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_and_reduce, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_int16_and_reduceiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_int16_and_reduceiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_int16_and_reduceiPsPKsm_nbst(shim_stream, shim_obj)


def int32_and_reduce():
    pass
    

def _lower__ZL24nvshmem_int32_and_reduceiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_int32_and_reduceiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int32_and_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_int32_and_reduceiPiPKim_nbst = declare_device(
        '_ZL24nvshmem_int32_and_reduceiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_int32_and_reduceiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_int32_and_reduceiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_and_reduce, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_int32_and_reduceiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_int32_and_reduceiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_int32_and_reduceiPiPKim_nbst(shim_stream, shim_obj)


def int64_and_reduce():
    pass
    

def _lower__ZL24nvshmem_int64_and_reduceiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_int64_and_reduceiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int64_and_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_int64_and_reduceiPlPKlm_nbst = declare_device(
        '_ZL24nvshmem_int64_and_reduceiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_int64_and_reduceiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_int64_and_reduceiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_and_reduce, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_int64_and_reduceiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_int64_and_reduceiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_int64_and_reduceiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_and_reduce():
    pass
    

def _lower__ZL24nvshmem_uint8_and_reduceiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_uint8_and_reduceiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint8_and_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_uint8_and_reduceiPhPKhm_nbst = declare_device(
        '_ZL24nvshmem_uint8_and_reduceiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_uint8_and_reduceiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_uint8_and_reduceiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_and_reduce, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_uint8_and_reduceiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_uint8_and_reduceiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_uint8_and_reduceiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_and_reduce():
    pass
    

def _lower__ZL25nvshmem_uint16_and_reduceiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_uint16_and_reduceiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint16_and_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_uint16_and_reduceiPtPKtm_nbst = declare_device(
        '_ZL25nvshmem_uint16_and_reduceiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_uint16_and_reduceiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_uint16_and_reduceiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_and_reduce, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_uint16_and_reduceiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_uint16_and_reduceiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_uint16_and_reduceiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_and_reduce():
    pass
    

def _lower__ZL25nvshmem_uint32_and_reduceiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_uint32_and_reduceiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint32_and_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_uint32_and_reduceiPjPKjm_nbst = declare_device(
        '_ZL25nvshmem_uint32_and_reduceiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_uint32_and_reduceiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_uint32_and_reduceiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_and_reduce, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_uint32_and_reduceiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_uint32_and_reduceiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_uint32_and_reduceiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_and_reduce():
    pass
    

def _lower__ZL25nvshmem_uint64_and_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_uint64_and_reduceiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint64_and_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_uint64_and_reduceiPmPKmm_nbst = declare_device(
        '_ZL25nvshmem_uint64_and_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_uint64_and_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_uint64_and_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_and_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_uint64_and_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_uint64_and_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_uint64_and_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def size_and_reduce():
    pass
    

def _lower__ZL23nvshmem_size_and_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_size_and_reduceiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_size_and_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_size_and_reduceiPmPKmm_nbst = declare_device(
        '_ZL23nvshmem_size_and_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_size_and_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_size_and_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_and_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_size_and_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_size_and_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_size_and_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def uchar_or_reduce():
    pass
    

def _lower__ZL23nvshmem_uchar_or_reduceiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_uchar_or_reduceiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmem_uchar_or_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_uchar_or_reduceiPhPKhm_nbst = declare_device(
        '_ZL23nvshmem_uchar_or_reduceiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_uchar_or_reduceiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_uchar_or_reduceiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_or_reduce, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_uchar_or_reduceiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_uchar_or_reduceiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_uchar_or_reduceiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_or_reduce():
    pass
    

def _lower__ZL24nvshmem_ushort_or_reduceiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_ushort_or_reduceiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmem_ushort_or_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_ushort_or_reduceiPtPKtm_nbst = declare_device(
        '_ZL24nvshmem_ushort_or_reduceiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_ushort_or_reduceiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_ushort_or_reduceiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_or_reduce, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_ushort_or_reduceiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_ushort_or_reduceiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_ushort_or_reduceiPtPKtm_nbst(shim_stream, shim_obj)


def uint_or_reduce():
    pass
    

def _lower__ZL22nvshmem_uint_or_reduceiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_uint_or_reduceiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmem_uint_or_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL22nvshmem_uint_or_reduceiPjPKjm_nbst = declare_device(
        '_ZL22nvshmem_uint_or_reduceiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_uint_or_reduceiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_uint_or_reduceiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_or_reduce, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_uint_or_reduceiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_uint_or_reduceiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_uint_or_reduceiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_or_reduce():
    pass
    

def _lower__ZL23nvshmem_ulong_or_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_ulong_or_reduceiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulong_or_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_ulong_or_reduceiPmPKmm_nbst = declare_device(
        '_ZL23nvshmem_ulong_or_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_ulong_or_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_ulong_or_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_or_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_ulong_or_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_ulong_or_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_ulong_or_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_or_reduce():
    pass
    

def _lower__ZL27nvshmem_ulonglong_or_reduceiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmem_ulonglong_or_reduceiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulonglong_or_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL27nvshmem_ulonglong_or_reduceiPyPKym_nbst = declare_device(
        '_ZL27nvshmem_ulonglong_or_reduceiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmem_ulonglong_or_reduceiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmem_ulonglong_or_reduceiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_or_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmem_ulonglong_or_reduceiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmem_ulonglong_or_reduceiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmem_ulonglong_or_reduceiPyPKym_nbst(shim_stream, shim_obj)


def int8_or_reduce():
    pass
    

def _lower__ZL22nvshmem_int8_or_reduceiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_int8_or_reduceiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int8_or_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL22nvshmem_int8_or_reduceiPaPKam_nbst = declare_device(
        '_ZL22nvshmem_int8_or_reduceiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_int8_or_reduceiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_int8_or_reduceiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_or_reduce, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_int8_or_reduceiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_int8_or_reduceiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_int8_or_reduceiPaPKam_nbst(shim_stream, shim_obj)


def int16_or_reduce():
    pass
    

def _lower__ZL23nvshmem_int16_or_reduceiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_int16_or_reduceiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int16_or_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_int16_or_reduceiPsPKsm_nbst = declare_device(
        '_ZL23nvshmem_int16_or_reduceiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_int16_or_reduceiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_int16_or_reduceiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_or_reduce, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_int16_or_reduceiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_int16_or_reduceiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_int16_or_reduceiPsPKsm_nbst(shim_stream, shim_obj)


def int32_or_reduce():
    pass
    

def _lower__ZL23nvshmem_int32_or_reduceiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_int32_or_reduceiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int32_or_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_int32_or_reduceiPiPKim_nbst = declare_device(
        '_ZL23nvshmem_int32_or_reduceiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_int32_or_reduceiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_int32_or_reduceiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_or_reduce, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_int32_or_reduceiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_int32_or_reduceiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_int32_or_reduceiPiPKim_nbst(shim_stream, shim_obj)


def int64_or_reduce():
    pass
    

def _lower__ZL23nvshmem_int64_or_reduceiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_int64_or_reduceiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int64_or_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_int64_or_reduceiPlPKlm_nbst = declare_device(
        '_ZL23nvshmem_int64_or_reduceiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_int64_or_reduceiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_int64_or_reduceiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_or_reduce, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_int64_or_reduceiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_int64_or_reduceiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_int64_or_reduceiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_or_reduce():
    pass
    

def _lower__ZL23nvshmem_uint8_or_reduceiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_uint8_or_reduceiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint8_or_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_uint8_or_reduceiPhPKhm_nbst = declare_device(
        '_ZL23nvshmem_uint8_or_reduceiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_uint8_or_reduceiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_uint8_or_reduceiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_or_reduce, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_uint8_or_reduceiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_uint8_or_reduceiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_uint8_or_reduceiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_or_reduce():
    pass
    

def _lower__ZL24nvshmem_uint16_or_reduceiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_uint16_or_reduceiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint16_or_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_uint16_or_reduceiPtPKtm_nbst = declare_device(
        '_ZL24nvshmem_uint16_or_reduceiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_uint16_or_reduceiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_uint16_or_reduceiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_or_reduce, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_uint16_or_reduceiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_uint16_or_reduceiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_uint16_or_reduceiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_or_reduce():
    pass
    

def _lower__ZL24nvshmem_uint32_or_reduceiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_uint32_or_reduceiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint32_or_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_uint32_or_reduceiPjPKjm_nbst = declare_device(
        '_ZL24nvshmem_uint32_or_reduceiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_uint32_or_reduceiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_uint32_or_reduceiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_or_reduce, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_uint32_or_reduceiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_uint32_or_reduceiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_uint32_or_reduceiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_or_reduce():
    pass
    

def _lower__ZL24nvshmem_uint64_or_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_uint64_or_reduceiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint64_or_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_uint64_or_reduceiPmPKmm_nbst = declare_device(
        '_ZL24nvshmem_uint64_or_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_uint64_or_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_uint64_or_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_or_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_uint64_or_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_uint64_or_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_uint64_or_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def size_or_reduce():
    pass
    

def _lower__ZL22nvshmem_size_or_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_size_or_reduceiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_size_or_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL22nvshmem_size_or_reduceiPmPKmm_nbst = declare_device(
        '_ZL22nvshmem_size_or_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_size_or_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_size_or_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_or_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_size_or_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_size_or_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_size_or_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def uchar_xor_reduce():
    pass
    

def _lower__ZL24nvshmem_uchar_xor_reduceiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_uchar_xor_reduceiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmem_uchar_xor_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_uchar_xor_reduceiPhPKhm_nbst = declare_device(
        '_ZL24nvshmem_uchar_xor_reduceiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_uchar_xor_reduceiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_uchar_xor_reduceiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_xor_reduce, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_uchar_xor_reduceiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_uchar_xor_reduceiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_uchar_xor_reduceiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_xor_reduce():
    pass
    

def _lower__ZL25nvshmem_ushort_xor_reduceiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_ushort_xor_reduceiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmem_ushort_xor_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_ushort_xor_reduceiPtPKtm_nbst = declare_device(
        '_ZL25nvshmem_ushort_xor_reduceiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_ushort_xor_reduceiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_ushort_xor_reduceiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_xor_reduce, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_ushort_xor_reduceiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_ushort_xor_reduceiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_ushort_xor_reduceiPtPKtm_nbst(shim_stream, shim_obj)


def uint_xor_reduce():
    pass
    

def _lower__ZL23nvshmem_uint_xor_reduceiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_uint_xor_reduceiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmem_uint_xor_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_uint_xor_reduceiPjPKjm_nbst = declare_device(
        '_ZL23nvshmem_uint_xor_reduceiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_uint_xor_reduceiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_uint_xor_reduceiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_xor_reduce, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_uint_xor_reduceiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_uint_xor_reduceiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_uint_xor_reduceiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_xor_reduce():
    pass
    

def _lower__ZL24nvshmem_ulong_xor_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_ulong_xor_reduceiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulong_xor_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_ulong_xor_reduceiPmPKmm_nbst = declare_device(
        '_ZL24nvshmem_ulong_xor_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_ulong_xor_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_ulong_xor_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_xor_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_ulong_xor_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_ulong_xor_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_ulong_xor_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_xor_reduce():
    pass
    

def _lower__ZL28nvshmem_ulonglong_xor_reduceiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmem_ulonglong_xor_reduceiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulonglong_xor_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL28nvshmem_ulonglong_xor_reduceiPyPKym_nbst = declare_device(
        '_ZL28nvshmem_ulonglong_xor_reduceiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmem_ulonglong_xor_reduceiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmem_ulonglong_xor_reduceiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_xor_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmem_ulonglong_xor_reduceiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmem_ulonglong_xor_reduceiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmem_ulonglong_xor_reduceiPyPKym_nbst(shim_stream, shim_obj)


def int8_xor_reduce():
    pass
    

def _lower__ZL23nvshmem_int8_xor_reduceiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_int8_xor_reduceiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int8_xor_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_int8_xor_reduceiPaPKam_nbst = declare_device(
        '_ZL23nvshmem_int8_xor_reduceiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_int8_xor_reduceiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_int8_xor_reduceiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_xor_reduce, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_int8_xor_reduceiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_int8_xor_reduceiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_int8_xor_reduceiPaPKam_nbst(shim_stream, shim_obj)


def int16_xor_reduce():
    pass
    

def _lower__ZL24nvshmem_int16_xor_reduceiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_int16_xor_reduceiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int16_xor_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_int16_xor_reduceiPsPKsm_nbst = declare_device(
        '_ZL24nvshmem_int16_xor_reduceiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_int16_xor_reduceiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_int16_xor_reduceiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_xor_reduce, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_int16_xor_reduceiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_int16_xor_reduceiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_int16_xor_reduceiPsPKsm_nbst(shim_stream, shim_obj)


def int32_xor_reduce():
    pass
    

def _lower__ZL24nvshmem_int32_xor_reduceiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_int32_xor_reduceiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int32_xor_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_int32_xor_reduceiPiPKim_nbst = declare_device(
        '_ZL24nvshmem_int32_xor_reduceiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_int32_xor_reduceiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_int32_xor_reduceiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_xor_reduce, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_int32_xor_reduceiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_int32_xor_reduceiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_int32_xor_reduceiPiPKim_nbst(shim_stream, shim_obj)


def int64_xor_reduce():
    pass
    

def _lower__ZL24nvshmem_int64_xor_reduceiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_int64_xor_reduceiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int64_xor_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_int64_xor_reduceiPlPKlm_nbst = declare_device(
        '_ZL24nvshmem_int64_xor_reduceiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_int64_xor_reduceiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_int64_xor_reduceiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_xor_reduce, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_int64_xor_reduceiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_int64_xor_reduceiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_int64_xor_reduceiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_xor_reduce():
    pass
    

def _lower__ZL24nvshmem_uint8_xor_reduceiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_uint8_xor_reduceiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint8_xor_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_uint8_xor_reduceiPhPKhm_nbst = declare_device(
        '_ZL24nvshmem_uint8_xor_reduceiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_uint8_xor_reduceiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_uint8_xor_reduceiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_xor_reduce, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_uint8_xor_reduceiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_uint8_xor_reduceiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_uint8_xor_reduceiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_xor_reduce():
    pass
    

def _lower__ZL25nvshmem_uint16_xor_reduceiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_uint16_xor_reduceiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint16_xor_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_uint16_xor_reduceiPtPKtm_nbst = declare_device(
        '_ZL25nvshmem_uint16_xor_reduceiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_uint16_xor_reduceiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_uint16_xor_reduceiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_xor_reduce, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_uint16_xor_reduceiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_uint16_xor_reduceiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_uint16_xor_reduceiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_xor_reduce():
    pass
    

def _lower__ZL25nvshmem_uint32_xor_reduceiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_uint32_xor_reduceiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint32_xor_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_uint32_xor_reduceiPjPKjm_nbst = declare_device(
        '_ZL25nvshmem_uint32_xor_reduceiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_uint32_xor_reduceiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_uint32_xor_reduceiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_xor_reduce, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_uint32_xor_reduceiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_uint32_xor_reduceiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_uint32_xor_reduceiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_xor_reduce():
    pass
    

def _lower__ZL25nvshmem_uint64_xor_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_uint64_xor_reduceiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint64_xor_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_uint64_xor_reduceiPmPKmm_nbst = declare_device(
        '_ZL25nvshmem_uint64_xor_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_uint64_xor_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_uint64_xor_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_xor_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_uint64_xor_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_uint64_xor_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_uint64_xor_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def size_xor_reduce():
    pass
    

def _lower__ZL23nvshmem_size_xor_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_size_xor_reduceiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_size_xor_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_size_xor_reduceiPmPKmm_nbst = declare_device(
        '_ZL23nvshmem_size_xor_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_size_xor_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_size_xor_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_xor_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_size_xor_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_size_xor_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_size_xor_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def uchar_max_reduce():
    pass
    

def _lower__ZL24nvshmem_uchar_max_reduceiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_uchar_max_reduceiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmem_uchar_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_uchar_max_reduceiPhPKhm_nbst = declare_device(
        '_ZL24nvshmem_uchar_max_reduceiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_uchar_max_reduceiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_uchar_max_reduceiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_max_reduce, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_uchar_max_reduceiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_uchar_max_reduceiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_uchar_max_reduceiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_max_reduce():
    pass
    

def _lower__ZL25nvshmem_ushort_max_reduceiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_ushort_max_reduceiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmem_ushort_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_ushort_max_reduceiPtPKtm_nbst = declare_device(
        '_ZL25nvshmem_ushort_max_reduceiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_ushort_max_reduceiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_ushort_max_reduceiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_max_reduce, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_ushort_max_reduceiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_ushort_max_reduceiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_ushort_max_reduceiPtPKtm_nbst(shim_stream, shim_obj)


def uint_max_reduce():
    pass
    

def _lower__ZL23nvshmem_uint_max_reduceiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_uint_max_reduceiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmem_uint_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_uint_max_reduceiPjPKjm_nbst = declare_device(
        '_ZL23nvshmem_uint_max_reduceiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_uint_max_reduceiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_uint_max_reduceiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_max_reduce, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_uint_max_reduceiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_uint_max_reduceiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_uint_max_reduceiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_max_reduce():
    pass
    

def _lower__ZL24nvshmem_ulong_max_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_ulong_max_reduceiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulong_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_ulong_max_reduceiPmPKmm_nbst = declare_device(
        '_ZL24nvshmem_ulong_max_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_ulong_max_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_ulong_max_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_max_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_ulong_max_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_ulong_max_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_ulong_max_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_max_reduce():
    pass
    

def _lower__ZL28nvshmem_ulonglong_max_reduceiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmem_ulonglong_max_reduceiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulonglong_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL28nvshmem_ulonglong_max_reduceiPyPKym_nbst = declare_device(
        '_ZL28nvshmem_ulonglong_max_reduceiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmem_ulonglong_max_reduceiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmem_ulonglong_max_reduceiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_max_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmem_ulonglong_max_reduceiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmem_ulonglong_max_reduceiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmem_ulonglong_max_reduceiPyPKym_nbst(shim_stream, shim_obj)


def int8_max_reduce():
    pass
    

def _lower__ZL23nvshmem_int8_max_reduceiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_int8_max_reduceiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int8_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_int8_max_reduceiPaPKam_nbst = declare_device(
        '_ZL23nvshmem_int8_max_reduceiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_int8_max_reduceiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_int8_max_reduceiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_max_reduce, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_int8_max_reduceiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_int8_max_reduceiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_int8_max_reduceiPaPKam_nbst(shim_stream, shim_obj)


def int16_max_reduce():
    pass
    

def _lower__ZL24nvshmem_int16_max_reduceiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_int16_max_reduceiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int16_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_int16_max_reduceiPsPKsm_nbst = declare_device(
        '_ZL24nvshmem_int16_max_reduceiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_int16_max_reduceiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_int16_max_reduceiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_max_reduce, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_int16_max_reduceiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_int16_max_reduceiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_int16_max_reduceiPsPKsm_nbst(shim_stream, shim_obj)


def int32_max_reduce():
    pass
    

def _lower__ZL24nvshmem_int32_max_reduceiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_int32_max_reduceiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int32_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_int32_max_reduceiPiPKim_nbst = declare_device(
        '_ZL24nvshmem_int32_max_reduceiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_int32_max_reduceiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_int32_max_reduceiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_max_reduce, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_int32_max_reduceiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_int32_max_reduceiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_int32_max_reduceiPiPKim_nbst(shim_stream, shim_obj)


def int64_max_reduce():
    pass
    

def _lower__ZL24nvshmem_int64_max_reduceiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_int64_max_reduceiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int64_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_int64_max_reduceiPlPKlm_nbst = declare_device(
        '_ZL24nvshmem_int64_max_reduceiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_int64_max_reduceiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_int64_max_reduceiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_max_reduce, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_int64_max_reduceiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_int64_max_reduceiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_int64_max_reduceiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_max_reduce():
    pass
    

def _lower__ZL24nvshmem_uint8_max_reduceiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_uint8_max_reduceiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint8_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_uint8_max_reduceiPhPKhm_nbst = declare_device(
        '_ZL24nvshmem_uint8_max_reduceiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_uint8_max_reduceiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_uint8_max_reduceiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_max_reduce, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_uint8_max_reduceiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_uint8_max_reduceiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_uint8_max_reduceiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_max_reduce():
    pass
    

def _lower__ZL25nvshmem_uint16_max_reduceiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_uint16_max_reduceiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint16_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_uint16_max_reduceiPtPKtm_nbst = declare_device(
        '_ZL25nvshmem_uint16_max_reduceiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_uint16_max_reduceiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_uint16_max_reduceiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_max_reduce, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_uint16_max_reduceiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_uint16_max_reduceiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_uint16_max_reduceiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_max_reduce():
    pass
    

def _lower__ZL25nvshmem_uint32_max_reduceiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_uint32_max_reduceiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint32_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_uint32_max_reduceiPjPKjm_nbst = declare_device(
        '_ZL25nvshmem_uint32_max_reduceiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_uint32_max_reduceiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_uint32_max_reduceiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_max_reduce, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_uint32_max_reduceiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_uint32_max_reduceiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_uint32_max_reduceiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_max_reduce():
    pass
    

def _lower__ZL25nvshmem_uint64_max_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_uint64_max_reduceiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint64_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_uint64_max_reduceiPmPKmm_nbst = declare_device(
        '_ZL25nvshmem_uint64_max_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_uint64_max_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_uint64_max_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_max_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_uint64_max_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_uint64_max_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_uint64_max_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def size_max_reduce():
    pass
    

def _lower__ZL23nvshmem_size_max_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_size_max_reduceiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_size_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_size_max_reduceiPmPKmm_nbst = declare_device(
        '_ZL23nvshmem_size_max_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_size_max_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_size_max_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_max_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_size_max_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_size_max_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_size_max_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def char_max_reduce():
    pass
    

def _lower__ZL23nvshmem_char_max_reduceiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_char_max_reduceiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmem_char_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_char_max_reduceiPcPKcm_nbst = declare_device(
        '_ZL23nvshmem_char_max_reduceiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_char_max_reduceiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_char_max_reduceiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_max_reduce, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_char_max_reduceiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_char_max_reduceiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_char_max_reduceiPcPKcm_nbst(shim_stream, shim_obj)


def schar_max_reduce():
    pass
    

def _lower__ZL24nvshmem_schar_max_reduceiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_schar_max_reduceiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmem_schar_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_schar_max_reduceiPaPKam_nbst = declare_device(
        '_ZL24nvshmem_schar_max_reduceiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_schar_max_reduceiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_schar_max_reduceiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_max_reduce, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_schar_max_reduceiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_schar_max_reduceiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_schar_max_reduceiPaPKam_nbst(shim_stream, shim_obj)


def short_max_reduce():
    pass
    

def _lower__ZL24nvshmem_short_max_reduceiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_short_max_reduceiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmem_short_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_short_max_reduceiPsPKsm_nbst = declare_device(
        '_ZL24nvshmem_short_max_reduceiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_short_max_reduceiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_short_max_reduceiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_max_reduce, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_short_max_reduceiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_short_max_reduceiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_short_max_reduceiPsPKsm_nbst(shim_stream, shim_obj)


def int_max_reduce():
    pass
    

def _lower__ZL22nvshmem_int_max_reduceiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_int_max_reduceiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmem_int_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL22nvshmem_int_max_reduceiPiPKim_nbst = declare_device(
        '_ZL22nvshmem_int_max_reduceiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_int_max_reduceiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_int_max_reduceiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_max_reduce, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_int_max_reduceiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_int_max_reduceiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_int_max_reduceiPiPKim_nbst(shim_stream, shim_obj)


def long_max_reduce():
    pass
    

def _lower__ZL23nvshmem_long_max_reduceiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_long_max_reduceiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmem_long_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_long_max_reduceiPlPKlm_nbst = declare_device(
        '_ZL23nvshmem_long_max_reduceiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_long_max_reduceiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_long_max_reduceiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_max_reduce, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_long_max_reduceiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_long_max_reduceiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_long_max_reduceiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_max_reduce():
    pass
    

def _lower__ZL27nvshmem_longlong_max_reduceiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmem_longlong_max_reduceiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmem_longlong_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL27nvshmem_longlong_max_reduceiPxPKxm_nbst = declare_device(
        '_ZL27nvshmem_longlong_max_reduceiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmem_longlong_max_reduceiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmem_longlong_max_reduceiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_max_reduce, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmem_longlong_max_reduceiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmem_longlong_max_reduceiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmem_longlong_max_reduceiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_max_reduce():
    pass
    

def _lower__ZL27nvshmem_bfloat16_max_reduceiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmem_bfloat16_max_reduceiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmem_bfloat16_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL27nvshmem_bfloat16_max_reduceiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL27nvshmem_bfloat16_max_reduceiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmem_bfloat16_max_reduceiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmem_bfloat16_max_reduceiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_max_reduce, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmem_bfloat16_max_reduceiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmem_bfloat16_max_reduceiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmem_bfloat16_max_reduceiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_max_reduce():
    pass
    

def _lower__ZL23nvshmem_half_max_reduceiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_half_max_reduceiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmem_half_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_half_max_reduceiP6__halfPKS_m_nbst = declare_device(
        '_ZL23nvshmem_half_max_reduceiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_half_max_reduceiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_half_max_reduceiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_max_reduce, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_half_max_reduceiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_half_max_reduceiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_half_max_reduceiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_max_reduce():
    pass
    

def _lower__ZL24nvshmem_float_max_reduceiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_float_max_reduceiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmem_float_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_float_max_reduceiPfPKfm_nbst = declare_device(
        '_ZL24nvshmem_float_max_reduceiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_float_max_reduceiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_float_max_reduceiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_max_reduce, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_float_max_reduceiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_float_max_reduceiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_float_max_reduceiPfPKfm_nbst(shim_stream, shim_obj)


def double_max_reduce():
    pass
    

def _lower__ZL25nvshmem_double_max_reduceiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_double_max_reduceiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmem_double_max_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_double_max_reduceiPdPKdm_nbst = declare_device(
        '_ZL25nvshmem_double_max_reduceiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_double_max_reduceiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_double_max_reduceiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_max_reduce, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_double_max_reduceiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_double_max_reduceiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_double_max_reduceiPdPKdm_nbst(shim_stream, shim_obj)


def uchar_min_reduce():
    pass
    

def _lower__ZL24nvshmem_uchar_min_reduceiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_uchar_min_reduceiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmem_uchar_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_uchar_min_reduceiPhPKhm_nbst = declare_device(
        '_ZL24nvshmem_uchar_min_reduceiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_uchar_min_reduceiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_uchar_min_reduceiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_min_reduce, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_uchar_min_reduceiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_uchar_min_reduceiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_uchar_min_reduceiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_min_reduce():
    pass
    

def _lower__ZL25nvshmem_ushort_min_reduceiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_ushort_min_reduceiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmem_ushort_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_ushort_min_reduceiPtPKtm_nbst = declare_device(
        '_ZL25nvshmem_ushort_min_reduceiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_ushort_min_reduceiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_ushort_min_reduceiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_min_reduce, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_ushort_min_reduceiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_ushort_min_reduceiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_ushort_min_reduceiPtPKtm_nbst(shim_stream, shim_obj)


def uint_min_reduce():
    pass
    

def _lower__ZL23nvshmem_uint_min_reduceiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_uint_min_reduceiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmem_uint_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_uint_min_reduceiPjPKjm_nbst = declare_device(
        '_ZL23nvshmem_uint_min_reduceiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_uint_min_reduceiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_uint_min_reduceiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_min_reduce, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_uint_min_reduceiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_uint_min_reduceiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_uint_min_reduceiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_min_reduce():
    pass
    

def _lower__ZL24nvshmem_ulong_min_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_ulong_min_reduceiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulong_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_ulong_min_reduceiPmPKmm_nbst = declare_device(
        '_ZL24nvshmem_ulong_min_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_ulong_min_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_ulong_min_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_min_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_ulong_min_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_ulong_min_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_ulong_min_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_min_reduce():
    pass
    

def _lower__ZL28nvshmem_ulonglong_min_reduceiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmem_ulonglong_min_reduceiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulonglong_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL28nvshmem_ulonglong_min_reduceiPyPKym_nbst = declare_device(
        '_ZL28nvshmem_ulonglong_min_reduceiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmem_ulonglong_min_reduceiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmem_ulonglong_min_reduceiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_min_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmem_ulonglong_min_reduceiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmem_ulonglong_min_reduceiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmem_ulonglong_min_reduceiPyPKym_nbst(shim_stream, shim_obj)


def int8_min_reduce():
    pass
    

def _lower__ZL23nvshmem_int8_min_reduceiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_int8_min_reduceiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int8_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_int8_min_reduceiPaPKam_nbst = declare_device(
        '_ZL23nvshmem_int8_min_reduceiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_int8_min_reduceiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_int8_min_reduceiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_min_reduce, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_int8_min_reduceiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_int8_min_reduceiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_int8_min_reduceiPaPKam_nbst(shim_stream, shim_obj)


def int16_min_reduce():
    pass
    

def _lower__ZL24nvshmem_int16_min_reduceiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_int16_min_reduceiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int16_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_int16_min_reduceiPsPKsm_nbst = declare_device(
        '_ZL24nvshmem_int16_min_reduceiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_int16_min_reduceiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_int16_min_reduceiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_min_reduce, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_int16_min_reduceiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_int16_min_reduceiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_int16_min_reduceiPsPKsm_nbst(shim_stream, shim_obj)


def int32_min_reduce():
    pass
    

def _lower__ZL24nvshmem_int32_min_reduceiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_int32_min_reduceiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int32_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_int32_min_reduceiPiPKim_nbst = declare_device(
        '_ZL24nvshmem_int32_min_reduceiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_int32_min_reduceiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_int32_min_reduceiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_min_reduce, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_int32_min_reduceiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_int32_min_reduceiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_int32_min_reduceiPiPKim_nbst(shim_stream, shim_obj)


def int64_min_reduce():
    pass
    

def _lower__ZL24nvshmem_int64_min_reduceiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_int64_min_reduceiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int64_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_int64_min_reduceiPlPKlm_nbst = declare_device(
        '_ZL24nvshmem_int64_min_reduceiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_int64_min_reduceiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_int64_min_reduceiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_min_reduce, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_int64_min_reduceiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_int64_min_reduceiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_int64_min_reduceiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_min_reduce():
    pass
    

def _lower__ZL24nvshmem_uint8_min_reduceiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_uint8_min_reduceiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint8_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_uint8_min_reduceiPhPKhm_nbst = declare_device(
        '_ZL24nvshmem_uint8_min_reduceiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_uint8_min_reduceiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_uint8_min_reduceiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_min_reduce, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_uint8_min_reduceiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_uint8_min_reduceiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_uint8_min_reduceiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_min_reduce():
    pass
    

def _lower__ZL25nvshmem_uint16_min_reduceiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_uint16_min_reduceiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint16_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_uint16_min_reduceiPtPKtm_nbst = declare_device(
        '_ZL25nvshmem_uint16_min_reduceiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_uint16_min_reduceiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_uint16_min_reduceiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_min_reduce, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_uint16_min_reduceiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_uint16_min_reduceiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_uint16_min_reduceiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_min_reduce():
    pass
    

def _lower__ZL25nvshmem_uint32_min_reduceiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_uint32_min_reduceiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint32_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_uint32_min_reduceiPjPKjm_nbst = declare_device(
        '_ZL25nvshmem_uint32_min_reduceiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_uint32_min_reduceiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_uint32_min_reduceiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_min_reduce, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_uint32_min_reduceiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_uint32_min_reduceiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_uint32_min_reduceiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_min_reduce():
    pass
    

def _lower__ZL25nvshmem_uint64_min_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_uint64_min_reduceiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint64_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_uint64_min_reduceiPmPKmm_nbst = declare_device(
        '_ZL25nvshmem_uint64_min_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_uint64_min_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_uint64_min_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_min_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_uint64_min_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_uint64_min_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_uint64_min_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def size_min_reduce():
    pass
    

def _lower__ZL23nvshmem_size_min_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_size_min_reduceiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_size_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_size_min_reduceiPmPKmm_nbst = declare_device(
        '_ZL23nvshmem_size_min_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_size_min_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_size_min_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_min_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_size_min_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_size_min_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_size_min_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def char_min_reduce():
    pass
    

def _lower__ZL23nvshmem_char_min_reduceiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_char_min_reduceiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmem_char_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_char_min_reduceiPcPKcm_nbst = declare_device(
        '_ZL23nvshmem_char_min_reduceiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_char_min_reduceiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_char_min_reduceiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_min_reduce, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_char_min_reduceiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_char_min_reduceiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_char_min_reduceiPcPKcm_nbst(shim_stream, shim_obj)


def schar_min_reduce():
    pass
    

def _lower__ZL24nvshmem_schar_min_reduceiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_schar_min_reduceiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmem_schar_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_schar_min_reduceiPaPKam_nbst = declare_device(
        '_ZL24nvshmem_schar_min_reduceiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_schar_min_reduceiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_schar_min_reduceiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_min_reduce, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_schar_min_reduceiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_schar_min_reduceiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_schar_min_reduceiPaPKam_nbst(shim_stream, shim_obj)


def short_min_reduce():
    pass
    

def _lower__ZL24nvshmem_short_min_reduceiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_short_min_reduceiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmem_short_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_short_min_reduceiPsPKsm_nbst = declare_device(
        '_ZL24nvshmem_short_min_reduceiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_short_min_reduceiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_short_min_reduceiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_min_reduce, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_short_min_reduceiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_short_min_reduceiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_short_min_reduceiPsPKsm_nbst(shim_stream, shim_obj)


def int_min_reduce():
    pass
    

def _lower__ZL22nvshmem_int_min_reduceiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_int_min_reduceiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmem_int_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL22nvshmem_int_min_reduceiPiPKim_nbst = declare_device(
        '_ZL22nvshmem_int_min_reduceiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_int_min_reduceiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_int_min_reduceiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_min_reduce, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_int_min_reduceiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_int_min_reduceiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_int_min_reduceiPiPKim_nbst(shim_stream, shim_obj)


def long_min_reduce():
    pass
    

def _lower__ZL23nvshmem_long_min_reduceiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_long_min_reduceiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmem_long_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_long_min_reduceiPlPKlm_nbst = declare_device(
        '_ZL23nvshmem_long_min_reduceiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_long_min_reduceiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_long_min_reduceiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_min_reduce, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_long_min_reduceiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_long_min_reduceiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_long_min_reduceiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_min_reduce():
    pass
    

def _lower__ZL27nvshmem_longlong_min_reduceiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmem_longlong_min_reduceiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmem_longlong_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL27nvshmem_longlong_min_reduceiPxPKxm_nbst = declare_device(
        '_ZL27nvshmem_longlong_min_reduceiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmem_longlong_min_reduceiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmem_longlong_min_reduceiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_min_reduce, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmem_longlong_min_reduceiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmem_longlong_min_reduceiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmem_longlong_min_reduceiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_min_reduce():
    pass
    

def _lower__ZL27nvshmem_bfloat16_min_reduceiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmem_bfloat16_min_reduceiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmem_bfloat16_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL27nvshmem_bfloat16_min_reduceiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL27nvshmem_bfloat16_min_reduceiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmem_bfloat16_min_reduceiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmem_bfloat16_min_reduceiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_min_reduce, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmem_bfloat16_min_reduceiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmem_bfloat16_min_reduceiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmem_bfloat16_min_reduceiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_min_reduce():
    pass
    

def _lower__ZL23nvshmem_half_min_reduceiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_half_min_reduceiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmem_half_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_half_min_reduceiP6__halfPKS_m_nbst = declare_device(
        '_ZL23nvshmem_half_min_reduceiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_half_min_reduceiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_half_min_reduceiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_min_reduce, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_half_min_reduceiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_half_min_reduceiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_half_min_reduceiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_min_reduce():
    pass
    

def _lower__ZL24nvshmem_float_min_reduceiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_float_min_reduceiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmem_float_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_float_min_reduceiPfPKfm_nbst = declare_device(
        '_ZL24nvshmem_float_min_reduceiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_float_min_reduceiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_float_min_reduceiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_min_reduce, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_float_min_reduceiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_float_min_reduceiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_float_min_reduceiPfPKfm_nbst(shim_stream, shim_obj)


def double_min_reduce():
    pass
    

def _lower__ZL25nvshmem_double_min_reduceiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_double_min_reduceiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmem_double_min_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_double_min_reduceiPdPKdm_nbst = declare_device(
        '_ZL25nvshmem_double_min_reduceiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_double_min_reduceiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_double_min_reduceiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_min_reduce, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_double_min_reduceiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_double_min_reduceiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_double_min_reduceiPdPKdm_nbst(shim_stream, shim_obj)


def uchar_sum_reduce():
    pass
    

def _lower__ZL24nvshmem_uchar_sum_reduceiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_uchar_sum_reduceiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmem_uchar_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_uchar_sum_reduceiPhPKhm_nbst = declare_device(
        '_ZL24nvshmem_uchar_sum_reduceiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_uchar_sum_reduceiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_uchar_sum_reduceiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_sum_reduce, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_uchar_sum_reduceiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_uchar_sum_reduceiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_uchar_sum_reduceiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_sum_reduce():
    pass
    

def _lower__ZL25nvshmem_ushort_sum_reduceiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_ushort_sum_reduceiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmem_ushort_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_ushort_sum_reduceiPtPKtm_nbst = declare_device(
        '_ZL25nvshmem_ushort_sum_reduceiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_ushort_sum_reduceiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_ushort_sum_reduceiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_sum_reduce, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_ushort_sum_reduceiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_ushort_sum_reduceiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_ushort_sum_reduceiPtPKtm_nbst(shim_stream, shim_obj)


def uint_sum_reduce():
    pass
    

def _lower__ZL23nvshmem_uint_sum_reduceiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_uint_sum_reduceiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmem_uint_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_uint_sum_reduceiPjPKjm_nbst = declare_device(
        '_ZL23nvshmem_uint_sum_reduceiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_uint_sum_reduceiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_uint_sum_reduceiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_sum_reduce, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_uint_sum_reduceiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_uint_sum_reduceiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_uint_sum_reduceiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_sum_reduce():
    pass
    

def _lower__ZL24nvshmem_ulong_sum_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_ulong_sum_reduceiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulong_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_ulong_sum_reduceiPmPKmm_nbst = declare_device(
        '_ZL24nvshmem_ulong_sum_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_ulong_sum_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_ulong_sum_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_sum_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_ulong_sum_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_ulong_sum_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_ulong_sum_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_sum_reduce():
    pass
    

def _lower__ZL28nvshmem_ulonglong_sum_reduceiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmem_ulonglong_sum_reduceiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulonglong_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL28nvshmem_ulonglong_sum_reduceiPyPKym_nbst = declare_device(
        '_ZL28nvshmem_ulonglong_sum_reduceiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmem_ulonglong_sum_reduceiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmem_ulonglong_sum_reduceiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_sum_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmem_ulonglong_sum_reduceiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmem_ulonglong_sum_reduceiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmem_ulonglong_sum_reduceiPyPKym_nbst(shim_stream, shim_obj)


def int8_sum_reduce():
    pass
    

def _lower__ZL23nvshmem_int8_sum_reduceiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_int8_sum_reduceiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int8_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_int8_sum_reduceiPaPKam_nbst = declare_device(
        '_ZL23nvshmem_int8_sum_reduceiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_int8_sum_reduceiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_int8_sum_reduceiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_sum_reduce, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_int8_sum_reduceiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_int8_sum_reduceiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_int8_sum_reduceiPaPKam_nbst(shim_stream, shim_obj)


def int16_sum_reduce():
    pass
    

def _lower__ZL24nvshmem_int16_sum_reduceiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_int16_sum_reduceiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int16_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_int16_sum_reduceiPsPKsm_nbst = declare_device(
        '_ZL24nvshmem_int16_sum_reduceiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_int16_sum_reduceiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_int16_sum_reduceiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_sum_reduce, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_int16_sum_reduceiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_int16_sum_reduceiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_int16_sum_reduceiPsPKsm_nbst(shim_stream, shim_obj)


def int32_sum_reduce():
    pass
    

def _lower__ZL24nvshmem_int32_sum_reduceiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_int32_sum_reduceiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int32_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_int32_sum_reduceiPiPKim_nbst = declare_device(
        '_ZL24nvshmem_int32_sum_reduceiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_int32_sum_reduceiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_int32_sum_reduceiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_sum_reduce, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_int32_sum_reduceiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_int32_sum_reduceiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_int32_sum_reduceiPiPKim_nbst(shim_stream, shim_obj)


def int64_sum_reduce():
    pass
    

def _lower__ZL24nvshmem_int64_sum_reduceiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_int64_sum_reduceiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int64_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_int64_sum_reduceiPlPKlm_nbst = declare_device(
        '_ZL24nvshmem_int64_sum_reduceiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_int64_sum_reduceiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_int64_sum_reduceiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_sum_reduce, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_int64_sum_reduceiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_int64_sum_reduceiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_int64_sum_reduceiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_sum_reduce():
    pass
    

def _lower__ZL24nvshmem_uint8_sum_reduceiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_uint8_sum_reduceiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint8_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_uint8_sum_reduceiPhPKhm_nbst = declare_device(
        '_ZL24nvshmem_uint8_sum_reduceiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_uint8_sum_reduceiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_uint8_sum_reduceiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_sum_reduce, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_uint8_sum_reduceiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_uint8_sum_reduceiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_uint8_sum_reduceiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_sum_reduce():
    pass
    

def _lower__ZL25nvshmem_uint16_sum_reduceiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_uint16_sum_reduceiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint16_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_uint16_sum_reduceiPtPKtm_nbst = declare_device(
        '_ZL25nvshmem_uint16_sum_reduceiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_uint16_sum_reduceiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_uint16_sum_reduceiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_sum_reduce, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_uint16_sum_reduceiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_uint16_sum_reduceiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_uint16_sum_reduceiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_sum_reduce():
    pass
    

def _lower__ZL25nvshmem_uint32_sum_reduceiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_uint32_sum_reduceiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint32_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_uint32_sum_reduceiPjPKjm_nbst = declare_device(
        '_ZL25nvshmem_uint32_sum_reduceiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_uint32_sum_reduceiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_uint32_sum_reduceiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_sum_reduce, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_uint32_sum_reduceiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_uint32_sum_reduceiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_uint32_sum_reduceiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_sum_reduce():
    pass
    

def _lower__ZL25nvshmem_uint64_sum_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_uint64_sum_reduceiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint64_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_uint64_sum_reduceiPmPKmm_nbst = declare_device(
        '_ZL25nvshmem_uint64_sum_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_uint64_sum_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_uint64_sum_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_sum_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_uint64_sum_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_uint64_sum_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_uint64_sum_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def size_sum_reduce():
    pass
    

def _lower__ZL23nvshmem_size_sum_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_size_sum_reduceiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_size_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_size_sum_reduceiPmPKmm_nbst = declare_device(
        '_ZL23nvshmem_size_sum_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_size_sum_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_size_sum_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_sum_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_size_sum_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_size_sum_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_size_sum_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def char_sum_reduce():
    pass
    

def _lower__ZL23nvshmem_char_sum_reduceiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_char_sum_reduceiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmem_char_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_char_sum_reduceiPcPKcm_nbst = declare_device(
        '_ZL23nvshmem_char_sum_reduceiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_char_sum_reduceiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_char_sum_reduceiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_sum_reduce, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_char_sum_reduceiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_char_sum_reduceiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_char_sum_reduceiPcPKcm_nbst(shim_stream, shim_obj)


def schar_sum_reduce():
    pass
    

def _lower__ZL24nvshmem_schar_sum_reduceiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_schar_sum_reduceiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmem_schar_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_schar_sum_reduceiPaPKam_nbst = declare_device(
        '_ZL24nvshmem_schar_sum_reduceiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_schar_sum_reduceiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_schar_sum_reduceiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_sum_reduce, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_schar_sum_reduceiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_schar_sum_reduceiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_schar_sum_reduceiPaPKam_nbst(shim_stream, shim_obj)


def short_sum_reduce():
    pass
    

def _lower__ZL24nvshmem_short_sum_reduceiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_short_sum_reduceiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmem_short_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_short_sum_reduceiPsPKsm_nbst = declare_device(
        '_ZL24nvshmem_short_sum_reduceiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_short_sum_reduceiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_short_sum_reduceiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_sum_reduce, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_short_sum_reduceiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_short_sum_reduceiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_short_sum_reduceiPsPKsm_nbst(shim_stream, shim_obj)


def int_sum_reduce():
    pass
    

def _lower__ZL22nvshmem_int_sum_reduceiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmem_int_sum_reduceiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmem_int_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL22nvshmem_int_sum_reduceiPiPKim_nbst = declare_device(
        '_ZL22nvshmem_int_sum_reduceiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL22nvshmem_int_sum_reduceiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL22nvshmem_int_sum_reduceiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_sum_reduce, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmem_int_sum_reduceiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmem_int_sum_reduceiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL22nvshmem_int_sum_reduceiPiPKim_nbst(shim_stream, shim_obj)


def long_sum_reduce():
    pass
    

def _lower__ZL23nvshmem_long_sum_reduceiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_long_sum_reduceiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmem_long_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_long_sum_reduceiPlPKlm_nbst = declare_device(
        '_ZL23nvshmem_long_sum_reduceiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_long_sum_reduceiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_long_sum_reduceiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_sum_reduce, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_long_sum_reduceiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_long_sum_reduceiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_long_sum_reduceiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_sum_reduce():
    pass
    

def _lower__ZL27nvshmem_longlong_sum_reduceiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmem_longlong_sum_reduceiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmem_longlong_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL27nvshmem_longlong_sum_reduceiPxPKxm_nbst = declare_device(
        '_ZL27nvshmem_longlong_sum_reduceiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmem_longlong_sum_reduceiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmem_longlong_sum_reduceiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_sum_reduce, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmem_longlong_sum_reduceiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmem_longlong_sum_reduceiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmem_longlong_sum_reduceiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_sum_reduce():
    pass
    

def _lower__ZL27nvshmem_bfloat16_sum_reduceiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmem_bfloat16_sum_reduceiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmem_bfloat16_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL27nvshmem_bfloat16_sum_reduceiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL27nvshmem_bfloat16_sum_reduceiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmem_bfloat16_sum_reduceiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmem_bfloat16_sum_reduceiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_sum_reduce, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmem_bfloat16_sum_reduceiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmem_bfloat16_sum_reduceiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmem_bfloat16_sum_reduceiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_sum_reduce():
    pass
    

def _lower__ZL23nvshmem_half_sum_reduceiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_half_sum_reduceiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmem_half_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_half_sum_reduceiP6__halfPKS_m_nbst = declare_device(
        '_ZL23nvshmem_half_sum_reduceiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_half_sum_reduceiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_half_sum_reduceiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_sum_reduce, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_half_sum_reduceiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_half_sum_reduceiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_half_sum_reduceiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_sum_reduce():
    pass
    

def _lower__ZL24nvshmem_float_sum_reduceiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_float_sum_reduceiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmem_float_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_float_sum_reduceiPfPKfm_nbst = declare_device(
        '_ZL24nvshmem_float_sum_reduceiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_float_sum_reduceiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_float_sum_reduceiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_sum_reduce, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_float_sum_reduceiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_float_sum_reduceiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_float_sum_reduceiPfPKfm_nbst(shim_stream, shim_obj)


def double_sum_reduce():
    pass
    

def _lower__ZL25nvshmem_double_sum_reduceiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_double_sum_reduceiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmem_double_sum_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_double_sum_reduceiPdPKdm_nbst = declare_device(
        '_ZL25nvshmem_double_sum_reduceiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_double_sum_reduceiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_double_sum_reduceiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_sum_reduce, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_double_sum_reduceiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_double_sum_reduceiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_double_sum_reduceiPdPKdm_nbst(shim_stream, shim_obj)


def uchar_prod_reduce():
    pass
    

def _lower__ZL25nvshmem_uchar_prod_reduceiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_uchar_prod_reduceiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmem_uchar_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_uchar_prod_reduceiPhPKhm_nbst = declare_device(
        '_ZL25nvshmem_uchar_prod_reduceiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_uchar_prod_reduceiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_uchar_prod_reduceiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_prod_reduce, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_uchar_prod_reduceiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_uchar_prod_reduceiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_uchar_prod_reduceiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_prod_reduce():
    pass
    

def _lower__ZL26nvshmem_ushort_prod_reduceiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL26nvshmem_ushort_prod_reduceiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmem_ushort_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL26nvshmem_ushort_prod_reduceiPtPKtm_nbst = declare_device(
        '_ZL26nvshmem_ushort_prod_reduceiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL26nvshmem_ushort_prod_reduceiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL26nvshmem_ushort_prod_reduceiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_prod_reduce, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL26nvshmem_ushort_prod_reduceiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL26nvshmem_ushort_prod_reduceiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL26nvshmem_ushort_prod_reduceiPtPKtm_nbst(shim_stream, shim_obj)


def uint_prod_reduce():
    pass
    

def _lower__ZL24nvshmem_uint_prod_reduceiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_uint_prod_reduceiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmem_uint_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_uint_prod_reduceiPjPKjm_nbst = declare_device(
        '_ZL24nvshmem_uint_prod_reduceiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_uint_prod_reduceiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_uint_prod_reduceiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_prod_reduce, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_uint_prod_reduceiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_uint_prod_reduceiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_uint_prod_reduceiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_prod_reduce():
    pass
    

def _lower__ZL25nvshmem_ulong_prod_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_ulong_prod_reduceiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulong_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_ulong_prod_reduceiPmPKmm_nbst = declare_device(
        '_ZL25nvshmem_ulong_prod_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_ulong_prod_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_ulong_prod_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_prod_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_ulong_prod_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_ulong_prod_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_ulong_prod_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_prod_reduce():
    pass
    

def _lower__ZL29nvshmem_ulonglong_prod_reduceiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmem_ulonglong_prod_reduceiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulonglong_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmem_ulonglong_prod_reduceiPyPKym_nbst = declare_device(
        '_ZL29nvshmem_ulonglong_prod_reduceiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmem_ulonglong_prod_reduceiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmem_ulonglong_prod_reduceiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_prod_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmem_ulonglong_prod_reduceiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmem_ulonglong_prod_reduceiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmem_ulonglong_prod_reduceiPyPKym_nbst(shim_stream, shim_obj)


def int8_prod_reduce():
    pass
    

def _lower__ZL24nvshmem_int8_prod_reduceiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_int8_prod_reduceiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int8_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_int8_prod_reduceiPaPKam_nbst = declare_device(
        '_ZL24nvshmem_int8_prod_reduceiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_int8_prod_reduceiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_int8_prod_reduceiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_prod_reduce, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_int8_prod_reduceiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_int8_prod_reduceiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_int8_prod_reduceiPaPKam_nbst(shim_stream, shim_obj)


def int16_prod_reduce():
    pass
    

def _lower__ZL25nvshmem_int16_prod_reduceiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_int16_prod_reduceiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int16_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_int16_prod_reduceiPsPKsm_nbst = declare_device(
        '_ZL25nvshmem_int16_prod_reduceiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_int16_prod_reduceiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_int16_prod_reduceiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_prod_reduce, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_int16_prod_reduceiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_int16_prod_reduceiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_int16_prod_reduceiPsPKsm_nbst(shim_stream, shim_obj)


def int32_prod_reduce():
    pass
    

def _lower__ZL25nvshmem_int32_prod_reduceiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_int32_prod_reduceiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int32_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_int32_prod_reduceiPiPKim_nbst = declare_device(
        '_ZL25nvshmem_int32_prod_reduceiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_int32_prod_reduceiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_int32_prod_reduceiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_prod_reduce, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_int32_prod_reduceiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_int32_prod_reduceiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_int32_prod_reduceiPiPKim_nbst(shim_stream, shim_obj)


def int64_prod_reduce():
    pass
    

def _lower__ZL25nvshmem_int64_prod_reduceiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_int64_prod_reduceiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int64_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_int64_prod_reduceiPlPKlm_nbst = declare_device(
        '_ZL25nvshmem_int64_prod_reduceiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_int64_prod_reduceiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_int64_prod_reduceiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_prod_reduce, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_int64_prod_reduceiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_int64_prod_reduceiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_int64_prod_reduceiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_prod_reduce():
    pass
    

def _lower__ZL25nvshmem_uint8_prod_reduceiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_uint8_prod_reduceiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint8_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_uint8_prod_reduceiPhPKhm_nbst = declare_device(
        '_ZL25nvshmem_uint8_prod_reduceiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_uint8_prod_reduceiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_uint8_prod_reduceiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_prod_reduce, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_uint8_prod_reduceiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_uint8_prod_reduceiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_uint8_prod_reduceiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_prod_reduce():
    pass
    

def _lower__ZL26nvshmem_uint16_prod_reduceiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL26nvshmem_uint16_prod_reduceiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint16_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL26nvshmem_uint16_prod_reduceiPtPKtm_nbst = declare_device(
        '_ZL26nvshmem_uint16_prod_reduceiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL26nvshmem_uint16_prod_reduceiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL26nvshmem_uint16_prod_reduceiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_prod_reduce, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL26nvshmem_uint16_prod_reduceiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL26nvshmem_uint16_prod_reduceiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL26nvshmem_uint16_prod_reduceiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_prod_reduce():
    pass
    

def _lower__ZL26nvshmem_uint32_prod_reduceiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL26nvshmem_uint32_prod_reduceiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint32_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL26nvshmem_uint32_prod_reduceiPjPKjm_nbst = declare_device(
        '_ZL26nvshmem_uint32_prod_reduceiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL26nvshmem_uint32_prod_reduceiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL26nvshmem_uint32_prod_reduceiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_prod_reduce, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL26nvshmem_uint32_prod_reduceiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL26nvshmem_uint32_prod_reduceiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL26nvshmem_uint32_prod_reduceiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_prod_reduce():
    pass
    

def _lower__ZL26nvshmem_uint64_prod_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL26nvshmem_uint64_prod_reduceiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint64_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL26nvshmem_uint64_prod_reduceiPmPKmm_nbst = declare_device(
        '_ZL26nvshmem_uint64_prod_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL26nvshmem_uint64_prod_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL26nvshmem_uint64_prod_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_prod_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL26nvshmem_uint64_prod_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL26nvshmem_uint64_prod_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL26nvshmem_uint64_prod_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def size_prod_reduce():
    pass
    

def _lower__ZL24nvshmem_size_prod_reduceiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_size_prod_reduceiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_size_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_size_prod_reduceiPmPKmm_nbst = declare_device(
        '_ZL24nvshmem_size_prod_reduceiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_size_prod_reduceiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_size_prod_reduceiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_prod_reduce, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_size_prod_reduceiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_size_prod_reduceiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_size_prod_reduceiPmPKmm_nbst(shim_stream, shim_obj)


def char_prod_reduce():
    pass
    

def _lower__ZL24nvshmem_char_prod_reduceiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_char_prod_reduceiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmem_char_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_char_prod_reduceiPcPKcm_nbst = declare_device(
        '_ZL24nvshmem_char_prod_reduceiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_char_prod_reduceiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_char_prod_reduceiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_prod_reduce, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_char_prod_reduceiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_char_prod_reduceiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_char_prod_reduceiPcPKcm_nbst(shim_stream, shim_obj)


def schar_prod_reduce():
    pass
    

def _lower__ZL25nvshmem_schar_prod_reduceiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_schar_prod_reduceiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmem_schar_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_schar_prod_reduceiPaPKam_nbst = declare_device(
        '_ZL25nvshmem_schar_prod_reduceiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_schar_prod_reduceiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_schar_prod_reduceiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_prod_reduce, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_schar_prod_reduceiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_schar_prod_reduceiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_schar_prod_reduceiPaPKam_nbst(shim_stream, shim_obj)


def short_prod_reduce():
    pass
    

def _lower__ZL25nvshmem_short_prod_reduceiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_short_prod_reduceiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmem_short_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_short_prod_reduceiPsPKsm_nbst = declare_device(
        '_ZL25nvshmem_short_prod_reduceiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_short_prod_reduceiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_short_prod_reduceiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_prod_reduce, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_short_prod_reduceiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_short_prod_reduceiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_short_prod_reduceiPsPKsm_nbst(shim_stream, shim_obj)


def int_prod_reduce():
    pass
    

def _lower__ZL23nvshmem_int_prod_reduceiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmem_int_prod_reduceiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmem_int_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL23nvshmem_int_prod_reduceiPiPKim_nbst = declare_device(
        '_ZL23nvshmem_int_prod_reduceiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL23nvshmem_int_prod_reduceiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL23nvshmem_int_prod_reduceiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_prod_reduce, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmem_int_prod_reduceiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmem_int_prod_reduceiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL23nvshmem_int_prod_reduceiPiPKim_nbst(shim_stream, shim_obj)


def long_prod_reduce():
    pass
    

def _lower__ZL24nvshmem_long_prod_reduceiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_long_prod_reduceiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmem_long_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_long_prod_reduceiPlPKlm_nbst = declare_device(
        '_ZL24nvshmem_long_prod_reduceiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_long_prod_reduceiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_long_prod_reduceiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_prod_reduce, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_long_prod_reduceiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_long_prod_reduceiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_long_prod_reduceiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_prod_reduce():
    pass
    

def _lower__ZL28nvshmem_longlong_prod_reduceiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmem_longlong_prod_reduceiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmem_longlong_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL28nvshmem_longlong_prod_reduceiPxPKxm_nbst = declare_device(
        '_ZL28nvshmem_longlong_prod_reduceiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmem_longlong_prod_reduceiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmem_longlong_prod_reduceiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_prod_reduce, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmem_longlong_prod_reduceiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmem_longlong_prod_reduceiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmem_longlong_prod_reduceiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_prod_reduce():
    pass
    

def _lower__ZL28nvshmem_bfloat16_prod_reduceiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmem_bfloat16_prod_reduceiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmem_bfloat16_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL28nvshmem_bfloat16_prod_reduceiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL28nvshmem_bfloat16_prod_reduceiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmem_bfloat16_prod_reduceiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmem_bfloat16_prod_reduceiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_prod_reduce, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmem_bfloat16_prod_reduceiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmem_bfloat16_prod_reduceiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmem_bfloat16_prod_reduceiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_prod_reduce():
    pass
    

def _lower__ZL24nvshmem_half_prod_reduceiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmem_half_prod_reduceiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmem_half_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL24nvshmem_half_prod_reduceiP6__halfPKS_m_nbst = declare_device(
        '_ZL24nvshmem_half_prod_reduceiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL24nvshmem_half_prod_reduceiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL24nvshmem_half_prod_reduceiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_prod_reduce, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmem_half_prod_reduceiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmem_half_prod_reduceiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL24nvshmem_half_prod_reduceiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_prod_reduce():
    pass
    

def _lower__ZL25nvshmem_float_prod_reduceiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmem_float_prod_reduceiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmem_float_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL25nvshmem_float_prod_reduceiPfPKfm_nbst = declare_device(
        '_ZL25nvshmem_float_prod_reduceiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmem_float_prod_reduceiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmem_float_prod_reduceiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_prod_reduce, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmem_float_prod_reduceiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmem_float_prod_reduceiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmem_float_prod_reduceiPfPKfm_nbst(shim_stream, shim_obj)


def double_prod_reduce():
    pass
    

def _lower__ZL26nvshmem_double_prod_reduceiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL26nvshmem_double_prod_reduceiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmem_double_prod_reduce(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL26nvshmem_double_prod_reduceiPdPKdm_nbst = declare_device(
        '_ZL26nvshmem_double_prod_reduceiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL26nvshmem_double_prod_reduceiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL26nvshmem_double_prod_reduceiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_prod_reduce, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL26nvshmem_double_prod_reduceiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL26nvshmem_double_prod_reduceiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL26nvshmem_double_prod_reduceiPdPKdm_nbst(shim_stream, shim_obj)


def uchar_and_reducescatter():
    pass
    

def _lower__ZL31nvshmem_uchar_and_reducescatteriPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_uchar_and_reducescatteriPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmem_uchar_and_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_uchar_and_reducescatteriPhPKhm_nbst = declare_device(
        '_ZL31nvshmem_uchar_and_reducescatteriPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_uchar_and_reducescatteriPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_uchar_and_reducescatteriPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_and_reducescatter, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_uchar_and_reducescatteriPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_uchar_and_reducescatteriPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_uchar_and_reducescatteriPhPKhm_nbst(shim_stream, shim_obj)


def ushort_and_reducescatter():
    pass
    

def _lower__ZL32nvshmem_ushort_and_reducescatteriPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_ushort_and_reducescatteriPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmem_ushort_and_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_ushort_and_reducescatteriPtPKtm_nbst = declare_device(
        '_ZL32nvshmem_ushort_and_reducescatteriPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_ushort_and_reducescatteriPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_ushort_and_reducescatteriPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_and_reducescatter, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_ushort_and_reducescatteriPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_ushort_and_reducescatteriPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_ushort_and_reducescatteriPtPKtm_nbst(shim_stream, shim_obj)


def uint_and_reducescatter():
    pass
    

def _lower__ZL30nvshmem_uint_and_reducescatteriPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_uint_and_reducescatteriPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmem_uint_and_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_uint_and_reducescatteriPjPKjm_nbst = declare_device(
        '_ZL30nvshmem_uint_and_reducescatteriPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_uint_and_reducescatteriPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_uint_and_reducescatteriPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_and_reducescatter, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_uint_and_reducescatteriPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_uint_and_reducescatteriPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_uint_and_reducescatteriPjPKjm_nbst(shim_stream, shim_obj)


def ulong_and_reducescatter():
    pass
    

def _lower__ZL31nvshmem_ulong_and_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_ulong_and_reducescatteriPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulong_and_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_ulong_and_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL31nvshmem_ulong_and_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_ulong_and_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_ulong_and_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_and_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_ulong_and_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_ulong_and_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_ulong_and_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_and_reducescatter():
    pass
    

def _lower__ZL35nvshmem_ulonglong_and_reducescatteriPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmem_ulonglong_and_reducescatteriPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulonglong_and_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmem_ulonglong_and_reducescatteriPyPKym_nbst = declare_device(
        '_ZL35nvshmem_ulonglong_and_reducescatteriPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmem_ulonglong_and_reducescatteriPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmem_ulonglong_and_reducescatteriPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_and_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL35nvshmem_ulonglong_and_reducescatteriPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmem_ulonglong_and_reducescatteriPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmem_ulonglong_and_reducescatteriPyPKym_nbst(shim_stream, shim_obj)


def int8_and_reducescatter():
    pass
    

def _lower__ZL30nvshmem_int8_and_reducescatteriPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_int8_and_reducescatteriPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int8_and_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_int8_and_reducescatteriPaPKam_nbst = declare_device(
        '_ZL30nvshmem_int8_and_reducescatteriPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_int8_and_reducescatteriPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_int8_and_reducescatteriPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_and_reducescatter, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_int8_and_reducescatteriPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_int8_and_reducescatteriPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_int8_and_reducescatteriPaPKam_nbst(shim_stream, shim_obj)


def int16_and_reducescatter():
    pass
    

def _lower__ZL31nvshmem_int16_and_reducescatteriPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_int16_and_reducescatteriPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int16_and_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_int16_and_reducescatteriPsPKsm_nbst = declare_device(
        '_ZL31nvshmem_int16_and_reducescatteriPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_int16_and_reducescatteriPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_int16_and_reducescatteriPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_and_reducescatter, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_int16_and_reducescatteriPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_int16_and_reducescatteriPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_int16_and_reducescatteriPsPKsm_nbst(shim_stream, shim_obj)


def int32_and_reducescatter():
    pass
    

def _lower__ZL31nvshmem_int32_and_reducescatteriPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_int32_and_reducescatteriPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int32_and_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_int32_and_reducescatteriPiPKim_nbst = declare_device(
        '_ZL31nvshmem_int32_and_reducescatteriPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_int32_and_reducescatteriPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_int32_and_reducescatteriPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_and_reducescatter, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_int32_and_reducescatteriPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_int32_and_reducescatteriPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_int32_and_reducescatteriPiPKim_nbst(shim_stream, shim_obj)


def int64_and_reducescatter():
    pass
    

def _lower__ZL31nvshmem_int64_and_reducescatteriPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_int64_and_reducescatteriPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int64_and_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_int64_and_reducescatteriPlPKlm_nbst = declare_device(
        '_ZL31nvshmem_int64_and_reducescatteriPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_int64_and_reducescatteriPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_int64_and_reducescatteriPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_and_reducescatter, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_int64_and_reducescatteriPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_int64_and_reducescatteriPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_int64_and_reducescatteriPlPKlm_nbst(shim_stream, shim_obj)


def uint8_and_reducescatter():
    pass
    

def _lower__ZL31nvshmem_uint8_and_reducescatteriPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_uint8_and_reducescatteriPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint8_and_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_uint8_and_reducescatteriPhPKhm_nbst = declare_device(
        '_ZL31nvshmem_uint8_and_reducescatteriPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_uint8_and_reducescatteriPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_uint8_and_reducescatteriPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_and_reducescatter, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_uint8_and_reducescatteriPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_uint8_and_reducescatteriPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_uint8_and_reducescatteriPhPKhm_nbst(shim_stream, shim_obj)


def uint16_and_reducescatter():
    pass
    

def _lower__ZL32nvshmem_uint16_and_reducescatteriPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_uint16_and_reducescatteriPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint16_and_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_uint16_and_reducescatteriPtPKtm_nbst = declare_device(
        '_ZL32nvshmem_uint16_and_reducescatteriPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_uint16_and_reducescatteriPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_uint16_and_reducescatteriPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_and_reducescatter, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_uint16_and_reducescatteriPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_uint16_and_reducescatteriPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_uint16_and_reducescatteriPtPKtm_nbst(shim_stream, shim_obj)


def uint32_and_reducescatter():
    pass
    

def _lower__ZL32nvshmem_uint32_and_reducescatteriPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_uint32_and_reducescatteriPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint32_and_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_uint32_and_reducescatteriPjPKjm_nbst = declare_device(
        '_ZL32nvshmem_uint32_and_reducescatteriPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_uint32_and_reducescatteriPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_uint32_and_reducescatteriPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_and_reducescatter, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_uint32_and_reducescatteriPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_uint32_and_reducescatteriPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_uint32_and_reducescatteriPjPKjm_nbst(shim_stream, shim_obj)


def uint64_and_reducescatter():
    pass
    

def _lower__ZL32nvshmem_uint64_and_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_uint64_and_reducescatteriPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint64_and_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_uint64_and_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL32nvshmem_uint64_and_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_uint64_and_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_uint64_and_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_and_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_uint64_and_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_uint64_and_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_uint64_and_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def size_and_reducescatter():
    pass
    

def _lower__ZL30nvshmem_size_and_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_size_and_reducescatteriPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_size_and_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_size_and_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL30nvshmem_size_and_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_size_and_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_size_and_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_and_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_size_and_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_size_and_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_size_and_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def uchar_or_reducescatter():
    pass
    

def _lower__ZL30nvshmem_uchar_or_reducescatteriPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_uchar_or_reducescatteriPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmem_uchar_or_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_uchar_or_reducescatteriPhPKhm_nbst = declare_device(
        '_ZL30nvshmem_uchar_or_reducescatteriPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_uchar_or_reducescatteriPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_uchar_or_reducescatteriPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_or_reducescatter, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_uchar_or_reducescatteriPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_uchar_or_reducescatteriPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_uchar_or_reducescatteriPhPKhm_nbst(shim_stream, shim_obj)


def ushort_or_reducescatter():
    pass
    

def _lower__ZL31nvshmem_ushort_or_reducescatteriPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_ushort_or_reducescatteriPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmem_ushort_or_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_ushort_or_reducescatteriPtPKtm_nbst = declare_device(
        '_ZL31nvshmem_ushort_or_reducescatteriPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_ushort_or_reducescatteriPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_ushort_or_reducescatteriPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_or_reducescatter, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_ushort_or_reducescatteriPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_ushort_or_reducescatteriPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_ushort_or_reducescatteriPtPKtm_nbst(shim_stream, shim_obj)


def uint_or_reducescatter():
    pass
    

def _lower__ZL29nvshmem_uint_or_reducescatteriPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmem_uint_or_reducescatteriPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmem_uint_or_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmem_uint_or_reducescatteriPjPKjm_nbst = declare_device(
        '_ZL29nvshmem_uint_or_reducescatteriPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmem_uint_or_reducescatteriPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmem_uint_or_reducescatteriPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_or_reducescatter, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmem_uint_or_reducescatteriPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmem_uint_or_reducescatteriPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmem_uint_or_reducescatteriPjPKjm_nbst(shim_stream, shim_obj)


def ulong_or_reducescatter():
    pass
    

def _lower__ZL30nvshmem_ulong_or_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_ulong_or_reducescatteriPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulong_or_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_ulong_or_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL30nvshmem_ulong_or_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_ulong_or_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_ulong_or_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_or_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_ulong_or_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_ulong_or_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_ulong_or_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_or_reducescatter():
    pass
    

def _lower__ZL34nvshmem_ulonglong_or_reducescatteriPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmem_ulonglong_or_reducescatteriPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulonglong_or_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmem_ulonglong_or_reducescatteriPyPKym_nbst = declare_device(
        '_ZL34nvshmem_ulonglong_or_reducescatteriPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmem_ulonglong_or_reducescatteriPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmem_ulonglong_or_reducescatteriPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_or_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmem_ulonglong_or_reducescatteriPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmem_ulonglong_or_reducescatteriPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmem_ulonglong_or_reducescatteriPyPKym_nbst(shim_stream, shim_obj)


def int8_or_reducescatter():
    pass
    

def _lower__ZL29nvshmem_int8_or_reducescatteriPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmem_int8_or_reducescatteriPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int8_or_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmem_int8_or_reducescatteriPaPKam_nbst = declare_device(
        '_ZL29nvshmem_int8_or_reducescatteriPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmem_int8_or_reducescatteriPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmem_int8_or_reducescatteriPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_or_reducescatter, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmem_int8_or_reducescatteriPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmem_int8_or_reducescatteriPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmem_int8_or_reducescatteriPaPKam_nbst(shim_stream, shim_obj)


def int16_or_reducescatter():
    pass
    

def _lower__ZL30nvshmem_int16_or_reducescatteriPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_int16_or_reducescatteriPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int16_or_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_int16_or_reducescatteriPsPKsm_nbst = declare_device(
        '_ZL30nvshmem_int16_or_reducescatteriPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_int16_or_reducescatteriPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_int16_or_reducescatteriPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_or_reducescatter, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_int16_or_reducescatteriPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_int16_or_reducescatteriPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_int16_or_reducescatteriPsPKsm_nbst(shim_stream, shim_obj)


def int32_or_reducescatter():
    pass
    

def _lower__ZL30nvshmem_int32_or_reducescatteriPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_int32_or_reducescatteriPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int32_or_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_int32_or_reducescatteriPiPKim_nbst = declare_device(
        '_ZL30nvshmem_int32_or_reducescatteriPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_int32_or_reducescatteriPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_int32_or_reducescatteriPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_or_reducescatter, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_int32_or_reducescatteriPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_int32_or_reducescatteriPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_int32_or_reducescatteriPiPKim_nbst(shim_stream, shim_obj)


def int64_or_reducescatter():
    pass
    

def _lower__ZL30nvshmem_int64_or_reducescatteriPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_int64_or_reducescatteriPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int64_or_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_int64_or_reducescatteriPlPKlm_nbst = declare_device(
        '_ZL30nvshmem_int64_or_reducescatteriPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_int64_or_reducescatteriPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_int64_or_reducescatteriPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_or_reducescatter, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_int64_or_reducescatteriPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_int64_or_reducescatteriPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_int64_or_reducescatteriPlPKlm_nbst(shim_stream, shim_obj)


def uint8_or_reducescatter():
    pass
    

def _lower__ZL30nvshmem_uint8_or_reducescatteriPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_uint8_or_reducescatteriPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint8_or_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_uint8_or_reducescatteriPhPKhm_nbst = declare_device(
        '_ZL30nvshmem_uint8_or_reducescatteriPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_uint8_or_reducescatteriPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_uint8_or_reducescatteriPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_or_reducescatter, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_uint8_or_reducescatteriPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_uint8_or_reducescatteriPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_uint8_or_reducescatteriPhPKhm_nbst(shim_stream, shim_obj)


def uint16_or_reducescatter():
    pass
    

def _lower__ZL31nvshmem_uint16_or_reducescatteriPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_uint16_or_reducescatteriPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint16_or_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_uint16_or_reducescatteriPtPKtm_nbst = declare_device(
        '_ZL31nvshmem_uint16_or_reducescatteriPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_uint16_or_reducescatteriPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_uint16_or_reducescatteriPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_or_reducescatter, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_uint16_or_reducescatteriPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_uint16_or_reducescatteriPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_uint16_or_reducescatteriPtPKtm_nbst(shim_stream, shim_obj)


def uint32_or_reducescatter():
    pass
    

def _lower__ZL31nvshmem_uint32_or_reducescatteriPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_uint32_or_reducescatteriPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint32_or_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_uint32_or_reducescatteriPjPKjm_nbst = declare_device(
        '_ZL31nvshmem_uint32_or_reducescatteriPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_uint32_or_reducescatteriPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_uint32_or_reducescatteriPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_or_reducescatter, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_uint32_or_reducescatteriPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_uint32_or_reducescatteriPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_uint32_or_reducescatteriPjPKjm_nbst(shim_stream, shim_obj)


def uint64_or_reducescatter():
    pass
    

def _lower__ZL31nvshmem_uint64_or_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_uint64_or_reducescatteriPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint64_or_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_uint64_or_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL31nvshmem_uint64_or_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_uint64_or_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_uint64_or_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_or_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_uint64_or_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_uint64_or_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_uint64_or_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def size_or_reducescatter():
    pass
    

def _lower__ZL29nvshmem_size_or_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmem_size_or_reducescatteriPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_size_or_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmem_size_or_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL29nvshmem_size_or_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmem_size_or_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmem_size_or_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_or_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmem_size_or_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmem_size_or_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmem_size_or_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def uchar_xor_reducescatter():
    pass
    

def _lower__ZL31nvshmem_uchar_xor_reducescatteriPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_uchar_xor_reducescatteriPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmem_uchar_xor_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_uchar_xor_reducescatteriPhPKhm_nbst = declare_device(
        '_ZL31nvshmem_uchar_xor_reducescatteriPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_uchar_xor_reducescatteriPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_uchar_xor_reducescatteriPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_xor_reducescatter, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_uchar_xor_reducescatteriPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_uchar_xor_reducescatteriPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_uchar_xor_reducescatteriPhPKhm_nbst(shim_stream, shim_obj)


def ushort_xor_reducescatter():
    pass
    

def _lower__ZL32nvshmem_ushort_xor_reducescatteriPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_ushort_xor_reducescatteriPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmem_ushort_xor_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_ushort_xor_reducescatteriPtPKtm_nbst = declare_device(
        '_ZL32nvshmem_ushort_xor_reducescatteriPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_ushort_xor_reducescatteriPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_ushort_xor_reducescatteriPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_xor_reducescatter, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_ushort_xor_reducescatteriPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_ushort_xor_reducescatteriPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_ushort_xor_reducescatteriPtPKtm_nbst(shim_stream, shim_obj)


def uint_xor_reducescatter():
    pass
    

def _lower__ZL30nvshmem_uint_xor_reducescatteriPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_uint_xor_reducescatteriPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmem_uint_xor_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_uint_xor_reducescatteriPjPKjm_nbst = declare_device(
        '_ZL30nvshmem_uint_xor_reducescatteriPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_uint_xor_reducescatteriPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_uint_xor_reducescatteriPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_xor_reducescatter, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_uint_xor_reducescatteriPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_uint_xor_reducescatteriPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_uint_xor_reducescatteriPjPKjm_nbst(shim_stream, shim_obj)


def ulong_xor_reducescatter():
    pass
    

def _lower__ZL31nvshmem_ulong_xor_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_ulong_xor_reducescatteriPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulong_xor_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_ulong_xor_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL31nvshmem_ulong_xor_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_ulong_xor_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_ulong_xor_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_xor_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_ulong_xor_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_ulong_xor_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_ulong_xor_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_xor_reducescatter():
    pass
    

def _lower__ZL35nvshmem_ulonglong_xor_reducescatteriPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmem_ulonglong_xor_reducescatteriPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulonglong_xor_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmem_ulonglong_xor_reducescatteriPyPKym_nbst = declare_device(
        '_ZL35nvshmem_ulonglong_xor_reducescatteriPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmem_ulonglong_xor_reducescatteriPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmem_ulonglong_xor_reducescatteriPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_xor_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL35nvshmem_ulonglong_xor_reducescatteriPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmem_ulonglong_xor_reducescatteriPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmem_ulonglong_xor_reducescatteriPyPKym_nbst(shim_stream, shim_obj)


def int8_xor_reducescatter():
    pass
    

def _lower__ZL30nvshmem_int8_xor_reducescatteriPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_int8_xor_reducescatteriPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int8_xor_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_int8_xor_reducescatteriPaPKam_nbst = declare_device(
        '_ZL30nvshmem_int8_xor_reducescatteriPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_int8_xor_reducescatteriPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_int8_xor_reducescatteriPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_xor_reducescatter, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_int8_xor_reducescatteriPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_int8_xor_reducescatteriPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_int8_xor_reducescatteriPaPKam_nbst(shim_stream, shim_obj)


def int16_xor_reducescatter():
    pass
    

def _lower__ZL31nvshmem_int16_xor_reducescatteriPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_int16_xor_reducescatteriPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int16_xor_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_int16_xor_reducescatteriPsPKsm_nbst = declare_device(
        '_ZL31nvshmem_int16_xor_reducescatteriPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_int16_xor_reducescatteriPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_int16_xor_reducescatteriPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_xor_reducescatter, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_int16_xor_reducescatteriPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_int16_xor_reducescatteriPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_int16_xor_reducescatteriPsPKsm_nbst(shim_stream, shim_obj)


def int32_xor_reducescatter():
    pass
    

def _lower__ZL31nvshmem_int32_xor_reducescatteriPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_int32_xor_reducescatteriPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int32_xor_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_int32_xor_reducescatteriPiPKim_nbst = declare_device(
        '_ZL31nvshmem_int32_xor_reducescatteriPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_int32_xor_reducescatteriPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_int32_xor_reducescatteriPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_xor_reducescatter, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_int32_xor_reducescatteriPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_int32_xor_reducescatteriPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_int32_xor_reducescatteriPiPKim_nbst(shim_stream, shim_obj)


def int64_xor_reducescatter():
    pass
    

def _lower__ZL31nvshmem_int64_xor_reducescatteriPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_int64_xor_reducescatteriPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int64_xor_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_int64_xor_reducescatteriPlPKlm_nbst = declare_device(
        '_ZL31nvshmem_int64_xor_reducescatteriPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_int64_xor_reducescatteriPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_int64_xor_reducescatteriPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_xor_reducescatter, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_int64_xor_reducescatteriPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_int64_xor_reducescatteriPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_int64_xor_reducescatteriPlPKlm_nbst(shim_stream, shim_obj)


def uint8_xor_reducescatter():
    pass
    

def _lower__ZL31nvshmem_uint8_xor_reducescatteriPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_uint8_xor_reducescatteriPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint8_xor_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_uint8_xor_reducescatteriPhPKhm_nbst = declare_device(
        '_ZL31nvshmem_uint8_xor_reducescatteriPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_uint8_xor_reducescatteriPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_uint8_xor_reducescatteriPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_xor_reducescatter, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_uint8_xor_reducescatteriPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_uint8_xor_reducescatteriPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_uint8_xor_reducescatteriPhPKhm_nbst(shim_stream, shim_obj)


def uint16_xor_reducescatter():
    pass
    

def _lower__ZL32nvshmem_uint16_xor_reducescatteriPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_uint16_xor_reducescatteriPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint16_xor_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_uint16_xor_reducescatteriPtPKtm_nbst = declare_device(
        '_ZL32nvshmem_uint16_xor_reducescatteriPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_uint16_xor_reducescatteriPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_uint16_xor_reducescatteriPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_xor_reducescatter, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_uint16_xor_reducescatteriPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_uint16_xor_reducescatteriPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_uint16_xor_reducescatteriPtPKtm_nbst(shim_stream, shim_obj)


def uint32_xor_reducescatter():
    pass
    

def _lower__ZL32nvshmem_uint32_xor_reducescatteriPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_uint32_xor_reducescatteriPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint32_xor_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_uint32_xor_reducescatteriPjPKjm_nbst = declare_device(
        '_ZL32nvshmem_uint32_xor_reducescatteriPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_uint32_xor_reducescatteriPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_uint32_xor_reducescatteriPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_xor_reducescatter, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_uint32_xor_reducescatteriPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_uint32_xor_reducescatteriPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_uint32_xor_reducescatteriPjPKjm_nbst(shim_stream, shim_obj)


def uint64_xor_reducescatter():
    pass
    

def _lower__ZL32nvshmem_uint64_xor_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_uint64_xor_reducescatteriPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint64_xor_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_uint64_xor_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL32nvshmem_uint64_xor_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_uint64_xor_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_uint64_xor_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_xor_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_uint64_xor_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_uint64_xor_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_uint64_xor_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def size_xor_reducescatter():
    pass
    

def _lower__ZL30nvshmem_size_xor_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_size_xor_reducescatteriPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_size_xor_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_size_xor_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL30nvshmem_size_xor_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_size_xor_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_size_xor_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_xor_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_size_xor_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_size_xor_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_size_xor_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def uchar_max_reducescatter():
    pass
    

def _lower__ZL31nvshmem_uchar_max_reducescatteriPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_uchar_max_reducescatteriPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmem_uchar_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_uchar_max_reducescatteriPhPKhm_nbst = declare_device(
        '_ZL31nvshmem_uchar_max_reducescatteriPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_uchar_max_reducescatteriPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_uchar_max_reducescatteriPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_max_reducescatter, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_uchar_max_reducescatteriPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_uchar_max_reducescatteriPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_uchar_max_reducescatteriPhPKhm_nbst(shim_stream, shim_obj)


def ushort_max_reducescatter():
    pass
    

def _lower__ZL32nvshmem_ushort_max_reducescatteriPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_ushort_max_reducescatteriPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmem_ushort_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_ushort_max_reducescatteriPtPKtm_nbst = declare_device(
        '_ZL32nvshmem_ushort_max_reducescatteriPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_ushort_max_reducescatteriPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_ushort_max_reducescatteriPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_max_reducescatter, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_ushort_max_reducescatteriPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_ushort_max_reducescatteriPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_ushort_max_reducescatteriPtPKtm_nbst(shim_stream, shim_obj)


def uint_max_reducescatter():
    pass
    

def _lower__ZL30nvshmem_uint_max_reducescatteriPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_uint_max_reducescatteriPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmem_uint_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_uint_max_reducescatteriPjPKjm_nbst = declare_device(
        '_ZL30nvshmem_uint_max_reducescatteriPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_uint_max_reducescatteriPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_uint_max_reducescatteriPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_max_reducescatter, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_uint_max_reducescatteriPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_uint_max_reducescatteriPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_uint_max_reducescatteriPjPKjm_nbst(shim_stream, shim_obj)


def ulong_max_reducescatter():
    pass
    

def _lower__ZL31nvshmem_ulong_max_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_ulong_max_reducescatteriPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulong_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_ulong_max_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL31nvshmem_ulong_max_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_ulong_max_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_ulong_max_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_max_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_ulong_max_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_ulong_max_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_ulong_max_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_max_reducescatter():
    pass
    

def _lower__ZL35nvshmem_ulonglong_max_reducescatteriPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmem_ulonglong_max_reducescatteriPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulonglong_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmem_ulonglong_max_reducescatteriPyPKym_nbst = declare_device(
        '_ZL35nvshmem_ulonglong_max_reducescatteriPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmem_ulonglong_max_reducescatteriPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmem_ulonglong_max_reducescatteriPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_max_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL35nvshmem_ulonglong_max_reducescatteriPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmem_ulonglong_max_reducescatteriPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmem_ulonglong_max_reducescatteriPyPKym_nbst(shim_stream, shim_obj)


def int8_max_reducescatter():
    pass
    

def _lower__ZL30nvshmem_int8_max_reducescatteriPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_int8_max_reducescatteriPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int8_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_int8_max_reducescatteriPaPKam_nbst = declare_device(
        '_ZL30nvshmem_int8_max_reducescatteriPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_int8_max_reducescatteriPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_int8_max_reducescatteriPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_max_reducescatter, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_int8_max_reducescatteriPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_int8_max_reducescatteriPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_int8_max_reducescatteriPaPKam_nbst(shim_stream, shim_obj)


def int16_max_reducescatter():
    pass
    

def _lower__ZL31nvshmem_int16_max_reducescatteriPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_int16_max_reducescatteriPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int16_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_int16_max_reducescatteriPsPKsm_nbst = declare_device(
        '_ZL31nvshmem_int16_max_reducescatteriPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_int16_max_reducescatteriPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_int16_max_reducescatteriPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_max_reducescatter, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_int16_max_reducescatteriPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_int16_max_reducescatteriPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_int16_max_reducescatteriPsPKsm_nbst(shim_stream, shim_obj)


def int32_max_reducescatter():
    pass
    

def _lower__ZL31nvshmem_int32_max_reducescatteriPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_int32_max_reducescatteriPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int32_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_int32_max_reducescatteriPiPKim_nbst = declare_device(
        '_ZL31nvshmem_int32_max_reducescatteriPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_int32_max_reducescatteriPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_int32_max_reducescatteriPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_max_reducescatter, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_int32_max_reducescatteriPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_int32_max_reducescatteriPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_int32_max_reducescatteriPiPKim_nbst(shim_stream, shim_obj)


def int64_max_reducescatter():
    pass
    

def _lower__ZL31nvshmem_int64_max_reducescatteriPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_int64_max_reducescatteriPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int64_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_int64_max_reducescatteriPlPKlm_nbst = declare_device(
        '_ZL31nvshmem_int64_max_reducescatteriPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_int64_max_reducescatteriPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_int64_max_reducescatteriPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_max_reducescatter, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_int64_max_reducescatteriPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_int64_max_reducescatteriPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_int64_max_reducescatteriPlPKlm_nbst(shim_stream, shim_obj)


def uint8_max_reducescatter():
    pass
    

def _lower__ZL31nvshmem_uint8_max_reducescatteriPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_uint8_max_reducescatteriPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint8_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_uint8_max_reducescatteriPhPKhm_nbst = declare_device(
        '_ZL31nvshmem_uint8_max_reducescatteriPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_uint8_max_reducescatteriPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_uint8_max_reducescatteriPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_max_reducescatter, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_uint8_max_reducescatteriPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_uint8_max_reducescatteriPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_uint8_max_reducescatteriPhPKhm_nbst(shim_stream, shim_obj)


def uint16_max_reducescatter():
    pass
    

def _lower__ZL32nvshmem_uint16_max_reducescatteriPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_uint16_max_reducescatteriPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint16_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_uint16_max_reducescatteriPtPKtm_nbst = declare_device(
        '_ZL32nvshmem_uint16_max_reducescatteriPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_uint16_max_reducescatteriPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_uint16_max_reducescatteriPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_max_reducescatter, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_uint16_max_reducescatteriPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_uint16_max_reducescatteriPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_uint16_max_reducescatteriPtPKtm_nbst(shim_stream, shim_obj)


def uint32_max_reducescatter():
    pass
    

def _lower__ZL32nvshmem_uint32_max_reducescatteriPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_uint32_max_reducescatteriPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint32_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_uint32_max_reducescatteriPjPKjm_nbst = declare_device(
        '_ZL32nvshmem_uint32_max_reducescatteriPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_uint32_max_reducescatteriPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_uint32_max_reducescatteriPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_max_reducescatter, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_uint32_max_reducescatteriPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_uint32_max_reducescatteriPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_uint32_max_reducescatteriPjPKjm_nbst(shim_stream, shim_obj)


def uint64_max_reducescatter():
    pass
    

def _lower__ZL32nvshmem_uint64_max_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_uint64_max_reducescatteriPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint64_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_uint64_max_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL32nvshmem_uint64_max_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_uint64_max_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_uint64_max_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_max_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_uint64_max_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_uint64_max_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_uint64_max_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def size_max_reducescatter():
    pass
    

def _lower__ZL30nvshmem_size_max_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_size_max_reducescatteriPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_size_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_size_max_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL30nvshmem_size_max_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_size_max_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_size_max_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_max_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_size_max_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_size_max_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_size_max_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def char_max_reducescatter():
    pass
    

def _lower__ZL30nvshmem_char_max_reducescatteriPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_char_max_reducescatteriPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmem_char_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_char_max_reducescatteriPcPKcm_nbst = declare_device(
        '_ZL30nvshmem_char_max_reducescatteriPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_char_max_reducescatteriPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_char_max_reducescatteriPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_max_reducescatter, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_char_max_reducescatteriPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_char_max_reducescatteriPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_char_max_reducescatteriPcPKcm_nbst(shim_stream, shim_obj)


def schar_max_reducescatter():
    pass
    

def _lower__ZL31nvshmem_schar_max_reducescatteriPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_schar_max_reducescatteriPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmem_schar_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_schar_max_reducescatteriPaPKam_nbst = declare_device(
        '_ZL31nvshmem_schar_max_reducescatteriPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_schar_max_reducescatteriPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_schar_max_reducescatteriPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_max_reducescatter, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_schar_max_reducescatteriPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_schar_max_reducescatteriPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_schar_max_reducescatteriPaPKam_nbst(shim_stream, shim_obj)


def short_max_reducescatter():
    pass
    

def _lower__ZL31nvshmem_short_max_reducescatteriPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_short_max_reducescatteriPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmem_short_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_short_max_reducescatteriPsPKsm_nbst = declare_device(
        '_ZL31nvshmem_short_max_reducescatteriPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_short_max_reducescatteriPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_short_max_reducescatteriPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_max_reducescatter, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_short_max_reducescatteriPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_short_max_reducescatteriPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_short_max_reducescatteriPsPKsm_nbst(shim_stream, shim_obj)


def int_max_reducescatter():
    pass
    

def _lower__ZL29nvshmem_int_max_reducescatteriPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmem_int_max_reducescatteriPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmem_int_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmem_int_max_reducescatteriPiPKim_nbst = declare_device(
        '_ZL29nvshmem_int_max_reducescatteriPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmem_int_max_reducescatteriPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmem_int_max_reducescatteriPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_max_reducescatter, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmem_int_max_reducescatteriPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmem_int_max_reducescatteriPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmem_int_max_reducescatteriPiPKim_nbst(shim_stream, shim_obj)


def long_max_reducescatter():
    pass
    

def _lower__ZL30nvshmem_long_max_reducescatteriPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_long_max_reducescatteriPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmem_long_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_long_max_reducescatteriPlPKlm_nbst = declare_device(
        '_ZL30nvshmem_long_max_reducescatteriPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_long_max_reducescatteriPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_long_max_reducescatteriPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_max_reducescatter, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_long_max_reducescatteriPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_long_max_reducescatteriPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_long_max_reducescatteriPlPKlm_nbst(shim_stream, shim_obj)


def longlong_max_reducescatter():
    pass
    

def _lower__ZL34nvshmem_longlong_max_reducescatteriPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmem_longlong_max_reducescatteriPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmem_longlong_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmem_longlong_max_reducescatteriPxPKxm_nbst = declare_device(
        '_ZL34nvshmem_longlong_max_reducescatteriPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmem_longlong_max_reducescatteriPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmem_longlong_max_reducescatteriPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_max_reducescatter, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmem_longlong_max_reducescatteriPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmem_longlong_max_reducescatteriPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmem_longlong_max_reducescatteriPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_max_reducescatter():
    pass
    

def _lower__ZL34nvshmem_bfloat16_max_reducescatteriP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmem_bfloat16_max_reducescatteriP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmem_bfloat16_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmem_bfloat16_max_reducescatteriP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL34nvshmem_bfloat16_max_reducescatteriP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmem_bfloat16_max_reducescatteriP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmem_bfloat16_max_reducescatteriP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_max_reducescatter, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmem_bfloat16_max_reducescatteriP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmem_bfloat16_max_reducescatteriP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmem_bfloat16_max_reducescatteriP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_max_reducescatter():
    pass
    

def _lower__ZL30nvshmem_half_max_reducescatteriP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_half_max_reducescatteriP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmem_half_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_half_max_reducescatteriP6__halfPKS_m_nbst = declare_device(
        '_ZL30nvshmem_half_max_reducescatteriP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_half_max_reducescatteriP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_half_max_reducescatteriP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_max_reducescatter, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_half_max_reducescatteriP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_half_max_reducescatteriP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_half_max_reducescatteriP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_max_reducescatter():
    pass
    

def _lower__ZL31nvshmem_float_max_reducescatteriPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_float_max_reducescatteriPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmem_float_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_float_max_reducescatteriPfPKfm_nbst = declare_device(
        '_ZL31nvshmem_float_max_reducescatteriPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_float_max_reducescatteriPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_float_max_reducescatteriPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_max_reducescatter, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_float_max_reducescatteriPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_float_max_reducescatteriPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_float_max_reducescatteriPfPKfm_nbst(shim_stream, shim_obj)


def double_max_reducescatter():
    pass
    

def _lower__ZL32nvshmem_double_max_reducescatteriPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_double_max_reducescatteriPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmem_double_max_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_double_max_reducescatteriPdPKdm_nbst = declare_device(
        '_ZL32nvshmem_double_max_reducescatteriPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_double_max_reducescatteriPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_double_max_reducescatteriPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_max_reducescatter, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_double_max_reducescatteriPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_double_max_reducescatteriPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_double_max_reducescatteriPdPKdm_nbst(shim_stream, shim_obj)


def uchar_min_reducescatter():
    pass
    

def _lower__ZL31nvshmem_uchar_min_reducescatteriPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_uchar_min_reducescatteriPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmem_uchar_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_uchar_min_reducescatteriPhPKhm_nbst = declare_device(
        '_ZL31nvshmem_uchar_min_reducescatteriPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_uchar_min_reducescatteriPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_uchar_min_reducescatteriPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_min_reducescatter, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_uchar_min_reducescatteriPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_uchar_min_reducescatteriPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_uchar_min_reducescatteriPhPKhm_nbst(shim_stream, shim_obj)


def ushort_min_reducescatter():
    pass
    

def _lower__ZL32nvshmem_ushort_min_reducescatteriPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_ushort_min_reducescatteriPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmem_ushort_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_ushort_min_reducescatteriPtPKtm_nbst = declare_device(
        '_ZL32nvshmem_ushort_min_reducescatteriPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_ushort_min_reducescatteriPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_ushort_min_reducescatteriPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_min_reducescatter, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_ushort_min_reducescatteriPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_ushort_min_reducescatteriPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_ushort_min_reducescatteriPtPKtm_nbst(shim_stream, shim_obj)


def uint_min_reducescatter():
    pass
    

def _lower__ZL30nvshmem_uint_min_reducescatteriPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_uint_min_reducescatteriPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmem_uint_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_uint_min_reducescatteriPjPKjm_nbst = declare_device(
        '_ZL30nvshmem_uint_min_reducescatteriPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_uint_min_reducescatteriPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_uint_min_reducescatteriPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_min_reducescatter, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_uint_min_reducescatteriPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_uint_min_reducescatteriPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_uint_min_reducescatteriPjPKjm_nbst(shim_stream, shim_obj)


def ulong_min_reducescatter():
    pass
    

def _lower__ZL31nvshmem_ulong_min_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_ulong_min_reducescatteriPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulong_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_ulong_min_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL31nvshmem_ulong_min_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_ulong_min_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_ulong_min_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_min_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_ulong_min_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_ulong_min_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_ulong_min_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_min_reducescatter():
    pass
    

def _lower__ZL35nvshmem_ulonglong_min_reducescatteriPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmem_ulonglong_min_reducescatteriPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulonglong_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmem_ulonglong_min_reducescatteriPyPKym_nbst = declare_device(
        '_ZL35nvshmem_ulonglong_min_reducescatteriPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmem_ulonglong_min_reducescatteriPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmem_ulonglong_min_reducescatteriPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_min_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL35nvshmem_ulonglong_min_reducescatteriPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmem_ulonglong_min_reducescatteriPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmem_ulonglong_min_reducescatteriPyPKym_nbst(shim_stream, shim_obj)


def int8_min_reducescatter():
    pass
    

def _lower__ZL30nvshmem_int8_min_reducescatteriPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_int8_min_reducescatteriPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int8_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_int8_min_reducescatteriPaPKam_nbst = declare_device(
        '_ZL30nvshmem_int8_min_reducescatteriPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_int8_min_reducescatteriPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_int8_min_reducescatteriPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_min_reducescatter, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_int8_min_reducescatteriPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_int8_min_reducescatteriPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_int8_min_reducescatteriPaPKam_nbst(shim_stream, shim_obj)


def int16_min_reducescatter():
    pass
    

def _lower__ZL31nvshmem_int16_min_reducescatteriPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_int16_min_reducescatteriPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int16_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_int16_min_reducescatteriPsPKsm_nbst = declare_device(
        '_ZL31nvshmem_int16_min_reducescatteriPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_int16_min_reducescatteriPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_int16_min_reducescatteriPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_min_reducescatter, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_int16_min_reducescatteriPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_int16_min_reducescatteriPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_int16_min_reducescatteriPsPKsm_nbst(shim_stream, shim_obj)


def int32_min_reducescatter():
    pass
    

def _lower__ZL31nvshmem_int32_min_reducescatteriPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_int32_min_reducescatteriPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int32_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_int32_min_reducescatteriPiPKim_nbst = declare_device(
        '_ZL31nvshmem_int32_min_reducescatteriPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_int32_min_reducescatteriPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_int32_min_reducescatteriPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_min_reducescatter, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_int32_min_reducescatteriPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_int32_min_reducescatteriPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_int32_min_reducescatteriPiPKim_nbst(shim_stream, shim_obj)


def int64_min_reducescatter():
    pass
    

def _lower__ZL31nvshmem_int64_min_reducescatteriPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_int64_min_reducescatteriPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int64_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_int64_min_reducescatteriPlPKlm_nbst = declare_device(
        '_ZL31nvshmem_int64_min_reducescatteriPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_int64_min_reducescatteriPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_int64_min_reducescatteriPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_min_reducescatter, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_int64_min_reducescatteriPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_int64_min_reducescatteriPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_int64_min_reducescatteriPlPKlm_nbst(shim_stream, shim_obj)


def uint8_min_reducescatter():
    pass
    

def _lower__ZL31nvshmem_uint8_min_reducescatteriPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_uint8_min_reducescatteriPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint8_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_uint8_min_reducescatteriPhPKhm_nbst = declare_device(
        '_ZL31nvshmem_uint8_min_reducescatteriPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_uint8_min_reducescatteriPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_uint8_min_reducescatteriPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_min_reducescatter, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_uint8_min_reducescatteriPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_uint8_min_reducescatteriPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_uint8_min_reducescatteriPhPKhm_nbst(shim_stream, shim_obj)


def uint16_min_reducescatter():
    pass
    

def _lower__ZL32nvshmem_uint16_min_reducescatteriPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_uint16_min_reducescatteriPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint16_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_uint16_min_reducescatteriPtPKtm_nbst = declare_device(
        '_ZL32nvshmem_uint16_min_reducescatteriPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_uint16_min_reducescatteriPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_uint16_min_reducescatteriPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_min_reducescatter, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_uint16_min_reducescatteriPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_uint16_min_reducescatteriPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_uint16_min_reducescatteriPtPKtm_nbst(shim_stream, shim_obj)


def uint32_min_reducescatter():
    pass
    

def _lower__ZL32nvshmem_uint32_min_reducescatteriPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_uint32_min_reducescatteriPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint32_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_uint32_min_reducescatteriPjPKjm_nbst = declare_device(
        '_ZL32nvshmem_uint32_min_reducescatteriPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_uint32_min_reducescatteriPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_uint32_min_reducescatteriPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_min_reducescatter, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_uint32_min_reducescatteriPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_uint32_min_reducescatteriPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_uint32_min_reducescatteriPjPKjm_nbst(shim_stream, shim_obj)


def uint64_min_reducescatter():
    pass
    

def _lower__ZL32nvshmem_uint64_min_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_uint64_min_reducescatteriPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint64_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_uint64_min_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL32nvshmem_uint64_min_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_uint64_min_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_uint64_min_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_min_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_uint64_min_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_uint64_min_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_uint64_min_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def size_min_reducescatter():
    pass
    

def _lower__ZL30nvshmem_size_min_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_size_min_reducescatteriPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_size_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_size_min_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL30nvshmem_size_min_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_size_min_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_size_min_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_min_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_size_min_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_size_min_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_size_min_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def char_min_reducescatter():
    pass
    

def _lower__ZL30nvshmem_char_min_reducescatteriPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_char_min_reducescatteriPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmem_char_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_char_min_reducescatteriPcPKcm_nbst = declare_device(
        '_ZL30nvshmem_char_min_reducescatteriPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_char_min_reducescatteriPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_char_min_reducescatteriPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_min_reducescatter, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_char_min_reducescatteriPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_char_min_reducescatteriPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_char_min_reducescatteriPcPKcm_nbst(shim_stream, shim_obj)


def schar_min_reducescatter():
    pass
    

def _lower__ZL31nvshmem_schar_min_reducescatteriPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_schar_min_reducescatteriPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmem_schar_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_schar_min_reducescatteriPaPKam_nbst = declare_device(
        '_ZL31nvshmem_schar_min_reducescatteriPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_schar_min_reducescatteriPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_schar_min_reducescatteriPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_min_reducescatter, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_schar_min_reducescatteriPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_schar_min_reducescatteriPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_schar_min_reducescatteriPaPKam_nbst(shim_stream, shim_obj)


def short_min_reducescatter():
    pass
    

def _lower__ZL31nvshmem_short_min_reducescatteriPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_short_min_reducescatteriPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmem_short_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_short_min_reducescatteriPsPKsm_nbst = declare_device(
        '_ZL31nvshmem_short_min_reducescatteriPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_short_min_reducescatteriPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_short_min_reducescatteriPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_min_reducescatter, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_short_min_reducescatteriPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_short_min_reducescatteriPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_short_min_reducescatteriPsPKsm_nbst(shim_stream, shim_obj)


def int_min_reducescatter():
    pass
    

def _lower__ZL29nvshmem_int_min_reducescatteriPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmem_int_min_reducescatteriPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmem_int_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmem_int_min_reducescatteriPiPKim_nbst = declare_device(
        '_ZL29nvshmem_int_min_reducescatteriPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmem_int_min_reducescatteriPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmem_int_min_reducescatteriPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_min_reducescatter, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmem_int_min_reducescatteriPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmem_int_min_reducescatteriPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmem_int_min_reducescatteriPiPKim_nbst(shim_stream, shim_obj)


def long_min_reducescatter():
    pass
    

def _lower__ZL30nvshmem_long_min_reducescatteriPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_long_min_reducescatteriPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmem_long_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_long_min_reducescatteriPlPKlm_nbst = declare_device(
        '_ZL30nvshmem_long_min_reducescatteriPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_long_min_reducescatteriPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_long_min_reducescatteriPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_min_reducescatter, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_long_min_reducescatteriPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_long_min_reducescatteriPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_long_min_reducescatteriPlPKlm_nbst(shim_stream, shim_obj)


def longlong_min_reducescatter():
    pass
    

def _lower__ZL34nvshmem_longlong_min_reducescatteriPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmem_longlong_min_reducescatteriPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmem_longlong_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmem_longlong_min_reducescatteriPxPKxm_nbst = declare_device(
        '_ZL34nvshmem_longlong_min_reducescatteriPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmem_longlong_min_reducescatteriPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmem_longlong_min_reducescatteriPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_min_reducescatter, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmem_longlong_min_reducescatteriPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmem_longlong_min_reducescatteriPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmem_longlong_min_reducescatteriPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_min_reducescatter():
    pass
    

def _lower__ZL34nvshmem_bfloat16_min_reducescatteriP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmem_bfloat16_min_reducescatteriP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmem_bfloat16_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmem_bfloat16_min_reducescatteriP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL34nvshmem_bfloat16_min_reducescatteriP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmem_bfloat16_min_reducescatteriP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmem_bfloat16_min_reducescatteriP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_min_reducescatter, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmem_bfloat16_min_reducescatteriP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmem_bfloat16_min_reducescatteriP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmem_bfloat16_min_reducescatteriP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_min_reducescatter():
    pass
    

def _lower__ZL30nvshmem_half_min_reducescatteriP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_half_min_reducescatteriP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmem_half_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_half_min_reducescatteriP6__halfPKS_m_nbst = declare_device(
        '_ZL30nvshmem_half_min_reducescatteriP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_half_min_reducescatteriP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_half_min_reducescatteriP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_min_reducescatter, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_half_min_reducescatteriP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_half_min_reducescatteriP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_half_min_reducescatteriP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_min_reducescatter():
    pass
    

def _lower__ZL31nvshmem_float_min_reducescatteriPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_float_min_reducescatteriPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmem_float_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_float_min_reducescatteriPfPKfm_nbst = declare_device(
        '_ZL31nvshmem_float_min_reducescatteriPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_float_min_reducescatteriPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_float_min_reducescatteriPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_min_reducescatter, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_float_min_reducescatteriPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_float_min_reducescatteriPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_float_min_reducescatteriPfPKfm_nbst(shim_stream, shim_obj)


def double_min_reducescatter():
    pass
    

def _lower__ZL32nvshmem_double_min_reducescatteriPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_double_min_reducescatteriPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmem_double_min_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_double_min_reducescatteriPdPKdm_nbst = declare_device(
        '_ZL32nvshmem_double_min_reducescatteriPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_double_min_reducescatteriPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_double_min_reducescatteriPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_min_reducescatter, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_double_min_reducescatteriPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_double_min_reducescatteriPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_double_min_reducescatteriPdPKdm_nbst(shim_stream, shim_obj)


def uchar_sum_reducescatter():
    pass
    

def _lower__ZL31nvshmem_uchar_sum_reducescatteriPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_uchar_sum_reducescatteriPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmem_uchar_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_uchar_sum_reducescatteriPhPKhm_nbst = declare_device(
        '_ZL31nvshmem_uchar_sum_reducescatteriPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_uchar_sum_reducescatteriPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_uchar_sum_reducescatteriPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_sum_reducescatter, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_uchar_sum_reducescatteriPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_uchar_sum_reducescatteriPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_uchar_sum_reducescatteriPhPKhm_nbst(shim_stream, shim_obj)


def ushort_sum_reducescatter():
    pass
    

def _lower__ZL32nvshmem_ushort_sum_reducescatteriPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_ushort_sum_reducescatteriPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmem_ushort_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_ushort_sum_reducescatteriPtPKtm_nbst = declare_device(
        '_ZL32nvshmem_ushort_sum_reducescatteriPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_ushort_sum_reducescatteriPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_ushort_sum_reducescatteriPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_sum_reducescatter, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_ushort_sum_reducescatteriPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_ushort_sum_reducescatteriPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_ushort_sum_reducescatteriPtPKtm_nbst(shim_stream, shim_obj)


def uint_sum_reducescatter():
    pass
    

def _lower__ZL30nvshmem_uint_sum_reducescatteriPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_uint_sum_reducescatteriPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmem_uint_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_uint_sum_reducescatteriPjPKjm_nbst = declare_device(
        '_ZL30nvshmem_uint_sum_reducescatteriPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_uint_sum_reducescatteriPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_uint_sum_reducescatteriPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_sum_reducescatter, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_uint_sum_reducescatteriPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_uint_sum_reducescatteriPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_uint_sum_reducescatteriPjPKjm_nbst(shim_stream, shim_obj)


def ulong_sum_reducescatter():
    pass
    

def _lower__ZL31nvshmem_ulong_sum_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_ulong_sum_reducescatteriPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulong_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_ulong_sum_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL31nvshmem_ulong_sum_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_ulong_sum_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_ulong_sum_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_sum_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_ulong_sum_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_ulong_sum_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_ulong_sum_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_sum_reducescatter():
    pass
    

def _lower__ZL35nvshmem_ulonglong_sum_reducescatteriPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmem_ulonglong_sum_reducescatteriPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulonglong_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmem_ulonglong_sum_reducescatteriPyPKym_nbst = declare_device(
        '_ZL35nvshmem_ulonglong_sum_reducescatteriPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmem_ulonglong_sum_reducescatteriPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmem_ulonglong_sum_reducescatteriPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_sum_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL35nvshmem_ulonglong_sum_reducescatteriPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmem_ulonglong_sum_reducescatteriPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmem_ulonglong_sum_reducescatteriPyPKym_nbst(shim_stream, shim_obj)


def int8_sum_reducescatter():
    pass
    

def _lower__ZL30nvshmem_int8_sum_reducescatteriPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_int8_sum_reducescatteriPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int8_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_int8_sum_reducescatteriPaPKam_nbst = declare_device(
        '_ZL30nvshmem_int8_sum_reducescatteriPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_int8_sum_reducescatteriPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_int8_sum_reducescatteriPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_sum_reducescatter, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_int8_sum_reducescatteriPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_int8_sum_reducescatteriPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_int8_sum_reducescatteriPaPKam_nbst(shim_stream, shim_obj)


def int16_sum_reducescatter():
    pass
    

def _lower__ZL31nvshmem_int16_sum_reducescatteriPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_int16_sum_reducescatteriPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int16_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_int16_sum_reducescatteriPsPKsm_nbst = declare_device(
        '_ZL31nvshmem_int16_sum_reducescatteriPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_int16_sum_reducescatteriPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_int16_sum_reducescatteriPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_sum_reducescatter, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_int16_sum_reducescatteriPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_int16_sum_reducescatteriPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_int16_sum_reducescatteriPsPKsm_nbst(shim_stream, shim_obj)


def int32_sum_reducescatter():
    pass
    

def _lower__ZL31nvshmem_int32_sum_reducescatteriPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_int32_sum_reducescatteriPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int32_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_int32_sum_reducescatteriPiPKim_nbst = declare_device(
        '_ZL31nvshmem_int32_sum_reducescatteriPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_int32_sum_reducescatteriPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_int32_sum_reducescatteriPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_sum_reducescatter, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_int32_sum_reducescatteriPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_int32_sum_reducescatteriPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_int32_sum_reducescatteriPiPKim_nbst(shim_stream, shim_obj)


def int64_sum_reducescatter():
    pass
    

def _lower__ZL31nvshmem_int64_sum_reducescatteriPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_int64_sum_reducescatteriPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int64_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_int64_sum_reducescatteriPlPKlm_nbst = declare_device(
        '_ZL31nvshmem_int64_sum_reducescatteriPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_int64_sum_reducescatteriPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_int64_sum_reducescatteriPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_sum_reducescatter, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_int64_sum_reducescatteriPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_int64_sum_reducescatteriPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_int64_sum_reducescatteriPlPKlm_nbst(shim_stream, shim_obj)


def uint8_sum_reducescatter():
    pass
    

def _lower__ZL31nvshmem_uint8_sum_reducescatteriPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_uint8_sum_reducescatteriPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint8_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_uint8_sum_reducescatteriPhPKhm_nbst = declare_device(
        '_ZL31nvshmem_uint8_sum_reducescatteriPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_uint8_sum_reducescatteriPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_uint8_sum_reducescatteriPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_sum_reducescatter, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_uint8_sum_reducescatteriPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_uint8_sum_reducescatteriPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_uint8_sum_reducescatteriPhPKhm_nbst(shim_stream, shim_obj)


def uint16_sum_reducescatter():
    pass
    

def _lower__ZL32nvshmem_uint16_sum_reducescatteriPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_uint16_sum_reducescatteriPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint16_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_uint16_sum_reducescatteriPtPKtm_nbst = declare_device(
        '_ZL32nvshmem_uint16_sum_reducescatteriPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_uint16_sum_reducescatteriPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_uint16_sum_reducescatteriPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_sum_reducescatter, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_uint16_sum_reducescatteriPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_uint16_sum_reducescatteriPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_uint16_sum_reducescatteriPtPKtm_nbst(shim_stream, shim_obj)


def uint32_sum_reducescatter():
    pass
    

def _lower__ZL32nvshmem_uint32_sum_reducescatteriPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_uint32_sum_reducescatteriPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint32_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_uint32_sum_reducescatteriPjPKjm_nbst = declare_device(
        '_ZL32nvshmem_uint32_sum_reducescatteriPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_uint32_sum_reducescatteriPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_uint32_sum_reducescatteriPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_sum_reducescatter, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_uint32_sum_reducescatteriPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_uint32_sum_reducescatteriPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_uint32_sum_reducescatteriPjPKjm_nbst(shim_stream, shim_obj)


def uint64_sum_reducescatter():
    pass
    

def _lower__ZL32nvshmem_uint64_sum_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_uint64_sum_reducescatteriPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint64_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_uint64_sum_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL32nvshmem_uint64_sum_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_uint64_sum_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_uint64_sum_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_sum_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_uint64_sum_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_uint64_sum_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_uint64_sum_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def size_sum_reducescatter():
    pass
    

def _lower__ZL30nvshmem_size_sum_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_size_sum_reducescatteriPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_size_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_size_sum_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL30nvshmem_size_sum_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_size_sum_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_size_sum_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_sum_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_size_sum_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_size_sum_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_size_sum_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def char_sum_reducescatter():
    pass
    

def _lower__ZL30nvshmem_char_sum_reducescatteriPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_char_sum_reducescatteriPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmem_char_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_char_sum_reducescatteriPcPKcm_nbst = declare_device(
        '_ZL30nvshmem_char_sum_reducescatteriPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_char_sum_reducescatteriPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_char_sum_reducescatteriPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_sum_reducescatter, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_char_sum_reducescatteriPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_char_sum_reducescatteriPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_char_sum_reducescatteriPcPKcm_nbst(shim_stream, shim_obj)


def schar_sum_reducescatter():
    pass
    

def _lower__ZL31nvshmem_schar_sum_reducescatteriPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_schar_sum_reducescatteriPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmem_schar_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_schar_sum_reducescatteriPaPKam_nbst = declare_device(
        '_ZL31nvshmem_schar_sum_reducescatteriPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_schar_sum_reducescatteriPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_schar_sum_reducescatteriPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_sum_reducescatter, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_schar_sum_reducescatteriPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_schar_sum_reducescatteriPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_schar_sum_reducescatteriPaPKam_nbst(shim_stream, shim_obj)


def short_sum_reducescatter():
    pass
    

def _lower__ZL31nvshmem_short_sum_reducescatteriPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_short_sum_reducescatteriPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmem_short_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_short_sum_reducescatteriPsPKsm_nbst = declare_device(
        '_ZL31nvshmem_short_sum_reducescatteriPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_short_sum_reducescatteriPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_short_sum_reducescatteriPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_sum_reducescatter, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_short_sum_reducescatteriPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_short_sum_reducescatteriPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_short_sum_reducescatteriPsPKsm_nbst(shim_stream, shim_obj)


def int_sum_reducescatter():
    pass
    

def _lower__ZL29nvshmem_int_sum_reducescatteriPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmem_int_sum_reducescatteriPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmem_int_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmem_int_sum_reducescatteriPiPKim_nbst = declare_device(
        '_ZL29nvshmem_int_sum_reducescatteriPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmem_int_sum_reducescatteriPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmem_int_sum_reducescatteriPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_sum_reducescatter, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmem_int_sum_reducescatteriPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmem_int_sum_reducescatteriPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmem_int_sum_reducescatteriPiPKim_nbst(shim_stream, shim_obj)


def long_sum_reducescatter():
    pass
    

def _lower__ZL30nvshmem_long_sum_reducescatteriPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_long_sum_reducescatteriPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmem_long_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_long_sum_reducescatteriPlPKlm_nbst = declare_device(
        '_ZL30nvshmem_long_sum_reducescatteriPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_long_sum_reducescatteriPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_long_sum_reducescatteriPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_sum_reducescatter, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_long_sum_reducescatteriPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_long_sum_reducescatteriPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_long_sum_reducescatteriPlPKlm_nbst(shim_stream, shim_obj)


def longlong_sum_reducescatter():
    pass
    

def _lower__ZL34nvshmem_longlong_sum_reducescatteriPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmem_longlong_sum_reducescatteriPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmem_longlong_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmem_longlong_sum_reducescatteriPxPKxm_nbst = declare_device(
        '_ZL34nvshmem_longlong_sum_reducescatteriPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmem_longlong_sum_reducescatteriPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmem_longlong_sum_reducescatteriPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_sum_reducescatter, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmem_longlong_sum_reducescatteriPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmem_longlong_sum_reducescatteriPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmem_longlong_sum_reducescatteriPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_sum_reducescatter():
    pass
    

def _lower__ZL34nvshmem_bfloat16_sum_reducescatteriP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmem_bfloat16_sum_reducescatteriP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmem_bfloat16_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmem_bfloat16_sum_reducescatteriP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL34nvshmem_bfloat16_sum_reducescatteriP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmem_bfloat16_sum_reducescatteriP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmem_bfloat16_sum_reducescatteriP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_sum_reducescatter, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmem_bfloat16_sum_reducescatteriP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmem_bfloat16_sum_reducescatteriP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmem_bfloat16_sum_reducescatteriP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_sum_reducescatter():
    pass
    

def _lower__ZL30nvshmem_half_sum_reducescatteriP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_half_sum_reducescatteriP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmem_half_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_half_sum_reducescatteriP6__halfPKS_m_nbst = declare_device(
        '_ZL30nvshmem_half_sum_reducescatteriP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_half_sum_reducescatteriP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_half_sum_reducescatteriP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_sum_reducescatter, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_half_sum_reducescatteriP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_half_sum_reducescatteriP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_half_sum_reducescatteriP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_sum_reducescatter():
    pass
    

def _lower__ZL31nvshmem_float_sum_reducescatteriPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_float_sum_reducescatteriPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmem_float_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_float_sum_reducescatteriPfPKfm_nbst = declare_device(
        '_ZL31nvshmem_float_sum_reducescatteriPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_float_sum_reducescatteriPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_float_sum_reducescatteriPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_sum_reducescatter, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_float_sum_reducescatteriPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_float_sum_reducescatteriPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_float_sum_reducescatteriPfPKfm_nbst(shim_stream, shim_obj)


def double_sum_reducescatter():
    pass
    

def _lower__ZL32nvshmem_double_sum_reducescatteriPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_double_sum_reducescatteriPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmem_double_sum_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_double_sum_reducescatteriPdPKdm_nbst = declare_device(
        '_ZL32nvshmem_double_sum_reducescatteriPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_double_sum_reducescatteriPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_double_sum_reducescatteriPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_sum_reducescatter, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_double_sum_reducescatteriPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_double_sum_reducescatteriPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_double_sum_reducescatteriPdPKdm_nbst(shim_stream, shim_obj)


def uchar_prod_reducescatter():
    pass
    

def _lower__ZL32nvshmem_uchar_prod_reducescatteriPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_uchar_prod_reducescatteriPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmem_uchar_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_uchar_prod_reducescatteriPhPKhm_nbst = declare_device(
        '_ZL32nvshmem_uchar_prod_reducescatteriPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_uchar_prod_reducescatteriPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_uchar_prod_reducescatteriPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_prod_reducescatter, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_uchar_prod_reducescatteriPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_uchar_prod_reducescatteriPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_uchar_prod_reducescatteriPhPKhm_nbst(shim_stream, shim_obj)


def ushort_prod_reducescatter():
    pass
    

def _lower__ZL33nvshmem_ushort_prod_reducescatteriPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmem_ushort_prod_reducescatteriPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmem_ushort_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL33nvshmem_ushort_prod_reducescatteriPtPKtm_nbst = declare_device(
        '_ZL33nvshmem_ushort_prod_reducescatteriPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL33nvshmem_ushort_prod_reducescatteriPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL33nvshmem_ushort_prod_reducescatteriPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_prod_reducescatter, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmem_ushort_prod_reducescatteriPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmem_ushort_prod_reducescatteriPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL33nvshmem_ushort_prod_reducescatteriPtPKtm_nbst(shim_stream, shim_obj)


def uint_prod_reducescatter():
    pass
    

def _lower__ZL31nvshmem_uint_prod_reducescatteriPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_uint_prod_reducescatteriPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmem_uint_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_uint_prod_reducescatteriPjPKjm_nbst = declare_device(
        '_ZL31nvshmem_uint_prod_reducescatteriPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_uint_prod_reducescatteriPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_uint_prod_reducescatteriPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_prod_reducescatter, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_uint_prod_reducescatteriPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_uint_prod_reducescatteriPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_uint_prod_reducescatteriPjPKjm_nbst(shim_stream, shim_obj)


def ulong_prod_reducescatter():
    pass
    

def _lower__ZL32nvshmem_ulong_prod_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_ulong_prod_reducescatteriPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulong_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_ulong_prod_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL32nvshmem_ulong_prod_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_ulong_prod_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_ulong_prod_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_prod_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_ulong_prod_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_ulong_prod_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_ulong_prod_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_prod_reducescatter():
    pass
    

def _lower__ZL36nvshmem_ulonglong_prod_reducescatteriPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmem_ulonglong_prod_reducescatteriPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmem_ulonglong_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmem_ulonglong_prod_reducescatteriPyPKym_nbst = declare_device(
        '_ZL36nvshmem_ulonglong_prod_reducescatteriPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmem_ulonglong_prod_reducescatteriPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmem_ulonglong_prod_reducescatteriPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_prod_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL36nvshmem_ulonglong_prod_reducescatteriPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmem_ulonglong_prod_reducescatteriPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmem_ulonglong_prod_reducescatteriPyPKym_nbst(shim_stream, shim_obj)


def int8_prod_reducescatter():
    pass
    

def _lower__ZL31nvshmem_int8_prod_reducescatteriPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_int8_prod_reducescatteriPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int8_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_int8_prod_reducescatteriPaPKam_nbst = declare_device(
        '_ZL31nvshmem_int8_prod_reducescatteriPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_int8_prod_reducescatteriPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_int8_prod_reducescatteriPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_prod_reducescatter, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_int8_prod_reducescatteriPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_int8_prod_reducescatteriPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_int8_prod_reducescatteriPaPKam_nbst(shim_stream, shim_obj)


def int16_prod_reducescatter():
    pass
    

def _lower__ZL32nvshmem_int16_prod_reducescatteriPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_int16_prod_reducescatteriPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int16_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_int16_prod_reducescatteriPsPKsm_nbst = declare_device(
        '_ZL32nvshmem_int16_prod_reducescatteriPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_int16_prod_reducescatteriPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_int16_prod_reducescatteriPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_prod_reducescatter, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_int16_prod_reducescatteriPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_int16_prod_reducescatteriPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_int16_prod_reducescatteriPsPKsm_nbst(shim_stream, shim_obj)


def int32_prod_reducescatter():
    pass
    

def _lower__ZL32nvshmem_int32_prod_reducescatteriPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_int32_prod_reducescatteriPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int32_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_int32_prod_reducescatteriPiPKim_nbst = declare_device(
        '_ZL32nvshmem_int32_prod_reducescatteriPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_int32_prod_reducescatteriPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_int32_prod_reducescatteriPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_prod_reducescatter, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_int32_prod_reducescatteriPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_int32_prod_reducescatteriPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_int32_prod_reducescatteriPiPKim_nbst(shim_stream, shim_obj)


def int64_prod_reducescatter():
    pass
    

def _lower__ZL32nvshmem_int64_prod_reducescatteriPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_int64_prod_reducescatteriPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_int64_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_int64_prod_reducescatteriPlPKlm_nbst = declare_device(
        '_ZL32nvshmem_int64_prod_reducescatteriPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_int64_prod_reducescatteriPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_int64_prod_reducescatteriPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_prod_reducescatter, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_int64_prod_reducescatteriPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_int64_prod_reducescatteriPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_int64_prod_reducescatteriPlPKlm_nbst(shim_stream, shim_obj)


def uint8_prod_reducescatter():
    pass
    

def _lower__ZL32nvshmem_uint8_prod_reducescatteriPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_uint8_prod_reducescatteriPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint8_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_uint8_prod_reducescatteriPhPKhm_nbst = declare_device(
        '_ZL32nvshmem_uint8_prod_reducescatteriPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_uint8_prod_reducescatteriPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_uint8_prod_reducescatteriPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_prod_reducescatter, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_uint8_prod_reducescatteriPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_uint8_prod_reducescatteriPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_uint8_prod_reducescatteriPhPKhm_nbst(shim_stream, shim_obj)


def uint16_prod_reducescatter():
    pass
    

def _lower__ZL33nvshmem_uint16_prod_reducescatteriPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmem_uint16_prod_reducescatteriPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint16_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL33nvshmem_uint16_prod_reducescatteriPtPKtm_nbst = declare_device(
        '_ZL33nvshmem_uint16_prod_reducescatteriPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL33nvshmem_uint16_prod_reducescatteriPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL33nvshmem_uint16_prod_reducescatteriPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_prod_reducescatter, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmem_uint16_prod_reducescatteriPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmem_uint16_prod_reducescatteriPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL33nvshmem_uint16_prod_reducescatteriPtPKtm_nbst(shim_stream, shim_obj)


def uint32_prod_reducescatter():
    pass
    

def _lower__ZL33nvshmem_uint32_prod_reducescatteriPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmem_uint32_prod_reducescatteriPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint32_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL33nvshmem_uint32_prod_reducescatteriPjPKjm_nbst = declare_device(
        '_ZL33nvshmem_uint32_prod_reducescatteriPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL33nvshmem_uint32_prod_reducescatteriPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL33nvshmem_uint32_prod_reducescatteriPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_prod_reducescatter, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmem_uint32_prod_reducescatteriPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmem_uint32_prod_reducescatteriPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL33nvshmem_uint32_prod_reducescatteriPjPKjm_nbst(shim_stream, shim_obj)


def uint64_prod_reducescatter():
    pass
    

def _lower__ZL33nvshmem_uint64_prod_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmem_uint64_prod_reducescatteriPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmem_uint64_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL33nvshmem_uint64_prod_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL33nvshmem_uint64_prod_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL33nvshmem_uint64_prod_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL33nvshmem_uint64_prod_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_prod_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmem_uint64_prod_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmem_uint64_prod_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL33nvshmem_uint64_prod_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def size_prod_reducescatter():
    pass
    

def _lower__ZL31nvshmem_size_prod_reducescatteriPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_size_prod_reducescatteriPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmem_size_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_size_prod_reducescatteriPmPKmm_nbst = declare_device(
        '_ZL31nvshmem_size_prod_reducescatteriPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_size_prod_reducescatteriPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_size_prod_reducescatteriPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_prod_reducescatter, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_size_prod_reducescatteriPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_size_prod_reducescatteriPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_size_prod_reducescatteriPmPKmm_nbst(shim_stream, shim_obj)


def char_prod_reducescatter():
    pass
    

def _lower__ZL31nvshmem_char_prod_reducescatteriPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_char_prod_reducescatteriPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmem_char_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_char_prod_reducescatteriPcPKcm_nbst = declare_device(
        '_ZL31nvshmem_char_prod_reducescatteriPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_char_prod_reducescatteriPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_char_prod_reducescatteriPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_prod_reducescatter, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_char_prod_reducescatteriPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_char_prod_reducescatteriPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_char_prod_reducescatteriPcPKcm_nbst(shim_stream, shim_obj)


def schar_prod_reducescatter():
    pass
    

def _lower__ZL32nvshmem_schar_prod_reducescatteriPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_schar_prod_reducescatteriPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmem_schar_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_schar_prod_reducescatteriPaPKam_nbst = declare_device(
        '_ZL32nvshmem_schar_prod_reducescatteriPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_schar_prod_reducescatteriPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_schar_prod_reducescatteriPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_prod_reducescatter, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_schar_prod_reducescatteriPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_schar_prod_reducescatteriPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_schar_prod_reducescatteriPaPKam_nbst(shim_stream, shim_obj)


def short_prod_reducescatter():
    pass
    

def _lower__ZL32nvshmem_short_prod_reducescatteriPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_short_prod_reducescatteriPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmem_short_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_short_prod_reducescatteriPsPKsm_nbst = declare_device(
        '_ZL32nvshmem_short_prod_reducescatteriPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_short_prod_reducescatteriPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_short_prod_reducescatteriPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_prod_reducescatter, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_short_prod_reducescatteriPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_short_prod_reducescatteriPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_short_prod_reducescatteriPsPKsm_nbst(shim_stream, shim_obj)


def int_prod_reducescatter():
    pass
    

def _lower__ZL30nvshmem_int_prod_reducescatteriPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmem_int_prod_reducescatteriPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmem_int_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmem_int_prod_reducescatteriPiPKim_nbst = declare_device(
        '_ZL30nvshmem_int_prod_reducescatteriPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmem_int_prod_reducescatteriPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmem_int_prod_reducescatteriPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_prod_reducescatter, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmem_int_prod_reducescatteriPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmem_int_prod_reducescatteriPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmem_int_prod_reducescatteriPiPKim_nbst(shim_stream, shim_obj)


def long_prod_reducescatter():
    pass
    

def _lower__ZL31nvshmem_long_prod_reducescatteriPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_long_prod_reducescatteriPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmem_long_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_long_prod_reducescatteriPlPKlm_nbst = declare_device(
        '_ZL31nvshmem_long_prod_reducescatteriPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_long_prod_reducescatteriPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_long_prod_reducescatteriPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_prod_reducescatter, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_long_prod_reducescatteriPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_long_prod_reducescatteriPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_long_prod_reducescatteriPlPKlm_nbst(shim_stream, shim_obj)


def longlong_prod_reducescatter():
    pass
    

def _lower__ZL35nvshmem_longlong_prod_reducescatteriPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmem_longlong_prod_reducescatteriPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmem_longlong_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmem_longlong_prod_reducescatteriPxPKxm_nbst = declare_device(
        '_ZL35nvshmem_longlong_prod_reducescatteriPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmem_longlong_prod_reducescatteriPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmem_longlong_prod_reducescatteriPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_prod_reducescatter, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL35nvshmem_longlong_prod_reducescatteriPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmem_longlong_prod_reducescatteriPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmem_longlong_prod_reducescatteriPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_prod_reducescatter():
    pass
    

def _lower__ZL35nvshmem_bfloat16_prod_reducescatteriP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmem_bfloat16_prod_reducescatteriP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmem_bfloat16_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmem_bfloat16_prod_reducescatteriP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL35nvshmem_bfloat16_prod_reducescatteriP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmem_bfloat16_prod_reducescatteriP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmem_bfloat16_prod_reducescatteriP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_prod_reducescatter, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL35nvshmem_bfloat16_prod_reducescatteriP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmem_bfloat16_prod_reducescatteriP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmem_bfloat16_prod_reducescatteriP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_prod_reducescatter():
    pass
    

def _lower__ZL31nvshmem_half_prod_reducescatteriP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmem_half_prod_reducescatteriP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmem_half_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmem_half_prod_reducescatteriP6__halfPKS_m_nbst = declare_device(
        '_ZL31nvshmem_half_prod_reducescatteriP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmem_half_prod_reducescatteriP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmem_half_prod_reducescatteriP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_prod_reducescatter, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmem_half_prod_reducescatteriP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmem_half_prod_reducescatteriP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmem_half_prod_reducescatteriP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_prod_reducescatter():
    pass
    

def _lower__ZL32nvshmem_float_prod_reducescatteriPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmem_float_prod_reducescatteriPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmem_float_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmem_float_prod_reducescatteriPfPKfm_nbst = declare_device(
        '_ZL32nvshmem_float_prod_reducescatteriPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmem_float_prod_reducescatteriPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmem_float_prod_reducescatteriPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_prod_reducescatter, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmem_float_prod_reducescatteriPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmem_float_prod_reducescatteriPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmem_float_prod_reducescatteriPfPKfm_nbst(shim_stream, shim_obj)


def double_prod_reducescatter():
    pass
    

def _lower__ZL33nvshmem_double_prod_reducescatteriPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmem_double_prod_reducescatteriPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmem_double_prod_reducescatter(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL33nvshmem_double_prod_reducescatteriPdPKdm_nbst = declare_device(
        '_ZL33nvshmem_double_prod_reducescatteriPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL33nvshmem_double_prod_reducescatteriPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL33nvshmem_double_prod_reducescatteriPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_prod_reducescatter, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmem_double_prod_reducescatteriPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmem_double_prod_reducescatteriPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL33nvshmem_double_prod_reducescatteriPdPKdm_nbst(shim_stream, shim_obj)


def vendor_get_version_info():
    pass
    

def _lower__Z32nvshmemx_vendor_get_version_info_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_vendor_get_version_info_nbst(int &retval , int ** major, int ** minor, int ** patch) {
        nvshmemx_vendor_get_version_info(*major, *minor, *patch);
        return 0;
    }
        """


    _Z32nvshmemx_vendor_get_version_info_nbst = declare_device(
        '_Z32nvshmemx_vendor_get_version_info_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(CPointer(int32))
        )
    )
    

    def _Z32nvshmemx_vendor_get_version_info_nbst_caller(arg_0, arg_1, arg_2):
        return _Z32nvshmemx_vendor_get_version_info_nbst(arg_0, arg_1, arg_2)
    

    @lower(vendor_get_version_info, CPointer(int32), CPointer(int32), CPointer(int32))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_vendor_get_version_info_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_vendor_get_version_info_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(CPointer(int32))),
            ptrs,
        )



_lower__Z32nvshmemx_vendor_get_version_info_nbst(shim_stream, shim_obj)


def signal_op():
    pass
    

def _lower__Z18nvshmemx_signal_op_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmemx_signal_op_nbst(int &retval , uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_signal_op(*sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z18nvshmemx_signal_op_nbst = declare_device(
        '_Z18nvshmemx_signal_op_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z18nvshmemx_signal_op_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmemx_signal_op_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(signal_op, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmemx_signal_op_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmemx_signal_op_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmemx_signal_op_nbst(shim_stream, shim_obj)


def mc_ptr():
    pass
    

def _lower__Z15nvshmemx_mc_ptr_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z15nvshmemx_mc_ptr_nbst(void * &retval , int* team, void ** ptr) {
        retval = nvshmemx_mc_ptr(*team, *ptr);
        return 0;
    }
        """


    _Z15nvshmemx_mc_ptr_nbst = declare_device(
        '_Z15nvshmemx_mc_ptr_nbst',
        CPointer(void)(
            CPointer(int32), CPointer(CPointer(void))
        )
    )
    

    def _Z15nvshmemx_mc_ptr_nbst_caller(arg_0, arg_1):
        return _Z15nvshmemx_mc_ptr_nbst(arg_0, arg_1)
    

    @lower(mc_ptr, int32, CPointer(void))
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z15nvshmemx_mc_ptr_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z15nvshmemx_mc_ptr_nbst_caller,
            signature(CPointer(void), CPointer(int32), CPointer(CPointer(void))),
            ptrs,
        )



_lower__Z15nvshmemx_mc_ptr_nbst(shim_stream, shim_obj)


def bfloat16_put_warp():
    pass
    

def _lower__Z26nvshmemx_bfloat16_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_bfloat16_put_warp_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe) {
        nvshmemx_bfloat16_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_bfloat16_put_warp_nbst = declare_device(
        '_Z26nvshmemx_bfloat16_put_warp_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_bfloat16_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_bfloat16_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_put_warp, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_bfloat16_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_bfloat16_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_bfloat16_put_warp_nbst(shim_stream, shim_obj)


def bfloat16_put_block():
    pass
    

def _lower__Z27nvshmemx_bfloat16_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_bfloat16_put_block_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe) {
        nvshmemx_bfloat16_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_bfloat16_put_block_nbst = declare_device(
        '_Z27nvshmemx_bfloat16_put_block_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_bfloat16_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_bfloat16_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_put_block, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_bfloat16_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_bfloat16_put_block_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_bfloat16_put_block_nbst(shim_stream, shim_obj)


def half_put_warp():
    pass
    

def _lower__Z22nvshmemx_half_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_half_put_warp_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe) {
        nvshmemx_half_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_half_put_warp_nbst = declare_device(
        '_Z22nvshmemx_half_put_warp_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_half_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmemx_half_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_put_warp, CPointer(float16), CPointer(float16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_half_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_half_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_half_put_warp_nbst(shim_stream, shim_obj)


def half_put_block():
    pass
    

def _lower__Z23nvshmemx_half_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_half_put_block_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe) {
        nvshmemx_half_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_half_put_block_nbst = declare_device(
        '_Z23nvshmemx_half_put_block_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_half_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_half_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_put_block, CPointer(float16), CPointer(float16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_half_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_half_put_block_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_half_put_block_nbst(shim_stream, shim_obj)


def float_put_warp():
    pass
    

def _lower__Z23nvshmemx_float_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_float_put_warp_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe) {
        nvshmemx_float_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_float_put_warp_nbst = declare_device(
        '_Z23nvshmemx_float_put_warp_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_float_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_float_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_put_warp, CPointer(float32), CPointer(float32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_float_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_float_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_float_put_warp_nbst(shim_stream, shim_obj)


def float_put_block():
    pass
    

def _lower__Z24nvshmemx_float_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_float_put_block_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe) {
        nvshmemx_float_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_float_put_block_nbst = declare_device(
        '_Z24nvshmemx_float_put_block_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_float_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_float_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_put_block, CPointer(float32), CPointer(float32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_float_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_float_put_block_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_float_put_block_nbst(shim_stream, shim_obj)


def double_put_warp():
    pass
    

def _lower__Z24nvshmemx_double_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_double_put_warp_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe) {
        nvshmemx_double_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_double_put_warp_nbst = declare_device(
        '_Z24nvshmemx_double_put_warp_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_double_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_double_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_put_warp, CPointer(float64), CPointer(float64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_double_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_double_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_double_put_warp_nbst(shim_stream, shim_obj)


def double_put_block():
    pass
    

def _lower__Z25nvshmemx_double_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_double_put_block_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe) {
        nvshmemx_double_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_double_put_block_nbst = declare_device(
        '_Z25nvshmemx_double_put_block_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_double_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmemx_double_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_put_block, CPointer(float64), CPointer(float64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_double_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_double_put_block_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_double_put_block_nbst(shim_stream, shim_obj)


def char_put_warp():
    pass
    

def _lower__Z22nvshmemx_char_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_char_put_warp_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_char_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_char_put_warp_nbst = declare_device(
        '_Z22nvshmemx_char_put_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_char_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmemx_char_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_put_warp, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_char_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_char_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_char_put_warp_nbst(shim_stream, shim_obj)


def char_put_block():
    pass
    

def _lower__Z23nvshmemx_char_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_char_put_block_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_char_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_char_put_block_nbst = declare_device(
        '_Z23nvshmemx_char_put_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_char_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_char_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_put_block, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_char_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_char_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_char_put_block_nbst(shim_stream, shim_obj)


def short_put_warp():
    pass
    

def _lower__Z23nvshmemx_short_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_short_put_warp_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe) {
        nvshmemx_short_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_short_put_warp_nbst = declare_device(
        '_Z23nvshmemx_short_put_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_short_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_short_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_put_warp, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_short_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_short_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_short_put_warp_nbst(shim_stream, shim_obj)


def short_put_block():
    pass
    

def _lower__Z24nvshmemx_short_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_short_put_block_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe) {
        nvshmemx_short_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_short_put_block_nbst = declare_device(
        '_Z24nvshmemx_short_put_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_short_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_short_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_put_block, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_short_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_short_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_short_put_block_nbst(shim_stream, shim_obj)


def schar_put_warp():
    pass
    

def _lower__Z23nvshmemx_schar_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_schar_put_warp_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_schar_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_schar_put_warp_nbst = declare_device(
        '_Z23nvshmemx_schar_put_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_schar_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_schar_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_put_warp, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_schar_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_schar_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_schar_put_warp_nbst(shim_stream, shim_obj)


def schar_put_block():
    pass
    

def _lower__Z24nvshmemx_schar_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_schar_put_block_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_schar_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_schar_put_block_nbst = declare_device(
        '_Z24nvshmemx_schar_put_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_schar_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_schar_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_put_block, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_schar_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_schar_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_schar_put_block_nbst(shim_stream, shim_obj)


def int_put_warp():
    pass
    

def _lower__Z21nvshmemx_int_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_int_put_warp_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmemx_int_put_warp_nbst = declare_device(
        '_Z21nvshmemx_int_put_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_int_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmemx_int_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_put_warp, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_int_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_int_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_int_put_warp_nbst(shim_stream, shim_obj)


def int_put_block():
    pass
    

def _lower__Z22nvshmemx_int_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_int_put_block_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_int_put_block_nbst = declare_device(
        '_Z22nvshmemx_int_put_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_int_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmemx_int_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_put_block, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_int_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_int_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_int_put_block_nbst(shim_stream, shim_obj)


def long_put_warp():
    pass
    

def _lower__Z22nvshmemx_long_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_long_put_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_long_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_long_put_warp_nbst = declare_device(
        '_Z22nvshmemx_long_put_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_long_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmemx_long_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_put_warp, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_long_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_long_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_long_put_warp_nbst(shim_stream, shim_obj)


def long_put_block():
    pass
    

def _lower__Z23nvshmemx_long_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_long_put_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_long_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_long_put_block_nbst = declare_device(
        '_Z23nvshmemx_long_put_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_long_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_long_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_put_block, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_long_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_long_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_long_put_block_nbst(shim_stream, shim_obj)


def longlong_put_warp():
    pass
    

def _lower__Z26nvshmemx_longlong_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_longlong_put_warp_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_longlong_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_longlong_put_warp_nbst = declare_device(
        '_Z26nvshmemx_longlong_put_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_longlong_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_longlong_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_put_warp, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_longlong_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_longlong_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_longlong_put_warp_nbst(shim_stream, shim_obj)


def longlong_put_block():
    pass
    

def _lower__Z27nvshmemx_longlong_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_longlong_put_block_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_longlong_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_longlong_put_block_nbst = declare_device(
        '_Z27nvshmemx_longlong_put_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_longlong_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_longlong_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_put_block, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_longlong_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_longlong_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_longlong_put_block_nbst(shim_stream, shim_obj)


def uchar_put_warp():
    pass
    

def _lower__Z23nvshmemx_uchar_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_uchar_put_warp_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uchar_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_uchar_put_warp_nbst = declare_device(
        '_Z23nvshmemx_uchar_put_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_uchar_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_uchar_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_put_warp, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_uchar_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_uchar_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_uchar_put_warp_nbst(shim_stream, shim_obj)


def uchar_put_block():
    pass
    

def _lower__Z24nvshmemx_uchar_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_uchar_put_block_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uchar_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_uchar_put_block_nbst = declare_device(
        '_Z24nvshmemx_uchar_put_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_uchar_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_uchar_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_put_block, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_uchar_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_uchar_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_uchar_put_block_nbst(shim_stream, shim_obj)


def ushort_put_warp():
    pass
    

def _lower__Z24nvshmemx_ushort_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_ushort_put_warp_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ushort_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_ushort_put_warp_nbst = declare_device(
        '_Z24nvshmemx_ushort_put_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_ushort_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_ushort_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_put_warp, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_ushort_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_ushort_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_ushort_put_warp_nbst(shim_stream, shim_obj)


def ushort_put_block():
    pass
    

def _lower__Z25nvshmemx_ushort_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_ushort_put_block_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ushort_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_ushort_put_block_nbst = declare_device(
        '_Z25nvshmemx_ushort_put_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_ushort_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmemx_ushort_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_put_block, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_ushort_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_ushort_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_ushort_put_block_nbst(shim_stream, shim_obj)


def uint_put_warp():
    pass
    

def _lower__Z22nvshmemx_uint_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_uint_put_warp_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_uint_put_warp_nbst = declare_device(
        '_Z22nvshmemx_uint_put_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_uint_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmemx_uint_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_put_warp, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_uint_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_uint_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_uint_put_warp_nbst(shim_stream, shim_obj)


def uint_put_block():
    pass
    

def _lower__Z23nvshmemx_uint_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_uint_put_block_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_uint_put_block_nbst = declare_device(
        '_Z23nvshmemx_uint_put_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_uint_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_uint_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_put_block, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_uint_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_uint_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_uint_put_block_nbst(shim_stream, shim_obj)


def ulong_put_warp():
    pass
    

def _lower__Z23nvshmemx_ulong_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_ulong_put_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ulong_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_ulong_put_warp_nbst = declare_device(
        '_Z23nvshmemx_ulong_put_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_ulong_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_ulong_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_put_warp, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_ulong_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_ulong_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_ulong_put_warp_nbst(shim_stream, shim_obj)


def ulong_put_block():
    pass
    

def _lower__Z24nvshmemx_ulong_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_ulong_put_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ulong_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_ulong_put_block_nbst = declare_device(
        '_Z24nvshmemx_ulong_put_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_ulong_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_ulong_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_put_block, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_ulong_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_ulong_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_ulong_put_block_nbst(shim_stream, shim_obj)


def ulonglong_put_warp():
    pass
    

def _lower__Z27nvshmemx_ulonglong_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_ulonglong_put_warp_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ulonglong_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_ulonglong_put_warp_nbst = declare_device(
        '_Z27nvshmemx_ulonglong_put_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_ulonglong_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_ulonglong_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_put_warp, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_ulonglong_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_ulonglong_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_ulonglong_put_warp_nbst(shim_stream, shim_obj)


def ulonglong_put_block():
    pass
    

def _lower__Z28nvshmemx_ulonglong_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_ulonglong_put_block_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ulonglong_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_ulonglong_put_block_nbst = declare_device(
        '_Z28nvshmemx_ulonglong_put_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_ulonglong_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_ulonglong_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_put_block, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_ulonglong_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_ulonglong_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_ulonglong_put_block_nbst(shim_stream, shim_obj)


def int8_put_warp():
    pass
    

def _lower__Z22nvshmemx_int8_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_int8_put_warp_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int8_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_int8_put_warp_nbst = declare_device(
        '_Z22nvshmemx_int8_put_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_int8_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmemx_int8_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_put_warp, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_int8_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_int8_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_int8_put_warp_nbst(shim_stream, shim_obj)


def int8_put_block():
    pass
    

def _lower__Z23nvshmemx_int8_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_int8_put_block_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int8_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_int8_put_block_nbst = declare_device(
        '_Z23nvshmemx_int8_put_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_int8_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_int8_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_put_block, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_int8_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_int8_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_int8_put_block_nbst(shim_stream, shim_obj)


def int16_put_warp():
    pass
    

def _lower__Z23nvshmemx_int16_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_int16_put_warp_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int16_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_int16_put_warp_nbst = declare_device(
        '_Z23nvshmemx_int16_put_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_int16_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_int16_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_put_warp, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_int16_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_int16_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_int16_put_warp_nbst(shim_stream, shim_obj)


def int16_put_block():
    pass
    

def _lower__Z24nvshmemx_int16_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_int16_put_block_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int16_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_int16_put_block_nbst = declare_device(
        '_Z24nvshmemx_int16_put_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_int16_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_int16_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_put_block, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_int16_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_int16_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_int16_put_block_nbst(shim_stream, shim_obj)


def int32_put_warp():
    pass
    

def _lower__Z23nvshmemx_int32_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_int32_put_warp_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int32_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_int32_put_warp_nbst = declare_device(
        '_Z23nvshmemx_int32_put_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_int32_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_int32_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_put_warp, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_int32_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_int32_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_int32_put_warp_nbst(shim_stream, shim_obj)


def int32_put_block():
    pass
    

def _lower__Z24nvshmemx_int32_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_int32_put_block_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int32_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_int32_put_block_nbst = declare_device(
        '_Z24nvshmemx_int32_put_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_int32_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_int32_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_put_block, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_int32_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_int32_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_int32_put_block_nbst(shim_stream, shim_obj)


def int64_put_warp():
    pass
    

def _lower__Z23nvshmemx_int64_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_int64_put_warp_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int64_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_int64_put_warp_nbst = declare_device(
        '_Z23nvshmemx_int64_put_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_int64_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_int64_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_put_warp, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_int64_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_int64_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_int64_put_warp_nbst(shim_stream, shim_obj)


def int64_put_block():
    pass
    

def _lower__Z24nvshmemx_int64_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_int64_put_block_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int64_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_int64_put_block_nbst = declare_device(
        '_Z24nvshmemx_int64_put_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_int64_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_int64_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_put_block, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_int64_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_int64_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_int64_put_block_nbst(shim_stream, shim_obj)


def uint8_put_warp():
    pass
    

def _lower__Z23nvshmemx_uint8_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_uint8_put_warp_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint8_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_uint8_put_warp_nbst = declare_device(
        '_Z23nvshmemx_uint8_put_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_uint8_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_uint8_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_put_warp, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_uint8_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_uint8_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_uint8_put_warp_nbst(shim_stream, shim_obj)


def uint8_put_block():
    pass
    

def _lower__Z24nvshmemx_uint8_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_uint8_put_block_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint8_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_uint8_put_block_nbst = declare_device(
        '_Z24nvshmemx_uint8_put_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_uint8_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_uint8_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_put_block, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_uint8_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_uint8_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_uint8_put_block_nbst(shim_stream, shim_obj)


def uint16_put_warp():
    pass
    

def _lower__Z24nvshmemx_uint16_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_uint16_put_warp_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint16_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_uint16_put_warp_nbst = declare_device(
        '_Z24nvshmemx_uint16_put_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_uint16_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_uint16_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_put_warp, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_uint16_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_uint16_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_uint16_put_warp_nbst(shim_stream, shim_obj)


def uint16_put_block():
    pass
    

def _lower__Z25nvshmemx_uint16_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_uint16_put_block_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint16_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_uint16_put_block_nbst = declare_device(
        '_Z25nvshmemx_uint16_put_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_uint16_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmemx_uint16_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_put_block, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_uint16_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_uint16_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_uint16_put_block_nbst(shim_stream, shim_obj)


def uint32_put_warp():
    pass
    

def _lower__Z24nvshmemx_uint32_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_uint32_put_warp_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint32_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_uint32_put_warp_nbst = declare_device(
        '_Z24nvshmemx_uint32_put_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_uint32_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_uint32_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_put_warp, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_uint32_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_uint32_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_uint32_put_warp_nbst(shim_stream, shim_obj)


def uint32_put_block():
    pass
    

def _lower__Z25nvshmemx_uint32_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_uint32_put_block_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint32_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_uint32_put_block_nbst = declare_device(
        '_Z25nvshmemx_uint32_put_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_uint32_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmemx_uint32_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_put_block, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_uint32_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_uint32_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_uint32_put_block_nbst(shim_stream, shim_obj)


def uint64_put_warp():
    pass
    

def _lower__Z24nvshmemx_uint64_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_uint64_put_warp_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint64_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_uint64_put_warp_nbst = declare_device(
        '_Z24nvshmemx_uint64_put_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_uint64_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_uint64_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_put_warp, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_uint64_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_uint64_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_uint64_put_warp_nbst(shim_stream, shim_obj)


def uint64_put_block():
    pass
    

def _lower__Z25nvshmemx_uint64_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_uint64_put_block_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint64_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_uint64_put_block_nbst = declare_device(
        '_Z25nvshmemx_uint64_put_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_uint64_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmemx_uint64_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_put_block, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_uint64_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_uint64_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_uint64_put_block_nbst(shim_stream, shim_obj)


def size_put_warp():
    pass
    

def _lower__Z22nvshmemx_size_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_size_put_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_size_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_size_put_warp_nbst = declare_device(
        '_Z22nvshmemx_size_put_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_size_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmemx_size_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_put_warp, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_size_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_size_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_size_put_warp_nbst(shim_stream, shim_obj)


def size_put_block():
    pass
    

def _lower__Z23nvshmemx_size_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_size_put_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_size_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_size_put_block_nbst = declare_device(
        '_Z23nvshmemx_size_put_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_size_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_size_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_put_block, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_size_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_size_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_size_put_block_nbst(shim_stream, shim_obj)


def ptrdiff_put_warp():
    pass
    

def _lower__Z25nvshmemx_ptrdiff_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_ptrdiff_put_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ptrdiff_put_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_ptrdiff_put_warp_nbst = declare_device(
        '_Z25nvshmemx_ptrdiff_put_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_ptrdiff_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmemx_ptrdiff_put_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ptrdiff_put_warp, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_ptrdiff_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_ptrdiff_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_ptrdiff_put_warp_nbst(shim_stream, shim_obj)


def ptrdiff_put_block():
    pass
    

def _lower__Z26nvshmemx_ptrdiff_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_ptrdiff_put_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ptrdiff_put_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_ptrdiff_put_block_nbst = declare_device(
        '_Z26nvshmemx_ptrdiff_put_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_ptrdiff_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_ptrdiff_put_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ptrdiff_put_block, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_ptrdiff_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_ptrdiff_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_ptrdiff_put_block_nbst(shim_stream, shim_obj)


def nvshmemi_bfloat16_put_signal_warp():
    pass
    

def _lower__Z33nvshmemi_bfloat16_put_signal_warpP13__nv_bfloat16PKS_mPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemi_bfloat16_put_signal_warpP13__nv_bfloat16PKS_mPmmiib_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_bfloat16_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z33nvshmemi_bfloat16_put_signal_warpP13__nv_bfloat16PKS_mPmmiib_nbst = declare_device(
        '_Z33nvshmemi_bfloat16_put_signal_warpP13__nv_bfloat16PKS_mPmmiib_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z33nvshmemi_bfloat16_put_signal_warpP13__nv_bfloat16PKS_mPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemi_bfloat16_put_signal_warpP13__nv_bfloat16PKS_mPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_bfloat16_put_signal_warp, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemi_bfloat16_put_signal_warpP13__nv_bfloat16PKS_mPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemi_bfloat16_put_signal_warpP13__nv_bfloat16PKS_mPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z33nvshmemi_bfloat16_put_signal_warpP13__nv_bfloat16PKS_mPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_half_put_signal_warp():
    pass
    

def _lower__Z29nvshmemi_half_put_signal_warpP6__halfPKS_mPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemi_half_put_signal_warpP6__halfPKS_mPmmiib_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_half_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z29nvshmemi_half_put_signal_warpP6__halfPKS_mPmmiib_nbst = declare_device(
        '_Z29nvshmemi_half_put_signal_warpP6__halfPKS_mPmmiib_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z29nvshmemi_half_put_signal_warpP6__halfPKS_mPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z29nvshmemi_half_put_signal_warpP6__halfPKS_mPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_half_put_signal_warp, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemi_half_put_signal_warpP6__halfPKS_mPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemi_half_put_signal_warpP6__halfPKS_mPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z29nvshmemi_half_put_signal_warpP6__halfPKS_mPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_float_put_signal_warp():
    pass
    

def _lower__Z30nvshmemi_float_put_signal_warpPfPKfmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemi_float_put_signal_warpPfPKfmPmmiib_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_float_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z30nvshmemi_float_put_signal_warpPfPKfmPmmiib_nbst = declare_device(
        '_Z30nvshmemi_float_put_signal_warpPfPKfmPmmiib_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z30nvshmemi_float_put_signal_warpPfPKfmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z30nvshmemi_float_put_signal_warpPfPKfmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_float_put_signal_warp, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemi_float_put_signal_warpPfPKfmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemi_float_put_signal_warpPfPKfmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z30nvshmemi_float_put_signal_warpPfPKfmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_double_put_signal_warp():
    pass
    

def _lower__Z31nvshmemi_double_put_signal_warpPdPKdmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemi_double_put_signal_warpPdPKdmPmmiib_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_double_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z31nvshmemi_double_put_signal_warpPdPKdmPmmiib_nbst = declare_device(
        '_Z31nvshmemi_double_put_signal_warpPdPKdmPmmiib_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z31nvshmemi_double_put_signal_warpPdPKdmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemi_double_put_signal_warpPdPKdmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_double_put_signal_warp, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemi_double_put_signal_warpPdPKdmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemi_double_put_signal_warpPdPKdmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z31nvshmemi_double_put_signal_warpPdPKdmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_char_put_signal_warp():
    pass
    

def _lower__Z29nvshmemi_char_put_signal_warpPcPKcmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemi_char_put_signal_warpPcPKcmPmmiib_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_char_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z29nvshmemi_char_put_signal_warpPcPKcmPmmiib_nbst = declare_device(
        '_Z29nvshmemi_char_put_signal_warpPcPKcmPmmiib_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z29nvshmemi_char_put_signal_warpPcPKcmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z29nvshmemi_char_put_signal_warpPcPKcmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_char_put_signal_warp, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemi_char_put_signal_warpPcPKcmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemi_char_put_signal_warpPcPKcmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z29nvshmemi_char_put_signal_warpPcPKcmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_short_put_signal_warp():
    pass
    

def _lower__Z30nvshmemi_short_put_signal_warpPsPKsmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemi_short_put_signal_warpPsPKsmPmmiib_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_short_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z30nvshmemi_short_put_signal_warpPsPKsmPmmiib_nbst = declare_device(
        '_Z30nvshmemi_short_put_signal_warpPsPKsmPmmiib_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z30nvshmemi_short_put_signal_warpPsPKsmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z30nvshmemi_short_put_signal_warpPsPKsmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_short_put_signal_warp, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemi_short_put_signal_warpPsPKsmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemi_short_put_signal_warpPsPKsmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z30nvshmemi_short_put_signal_warpPsPKsmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_schar_put_signal_warp():
    pass
    

def _lower__Z30nvshmemi_schar_put_signal_warpPaPKamPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemi_schar_put_signal_warpPaPKamPmmiib_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_schar_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z30nvshmemi_schar_put_signal_warpPaPKamPmmiib_nbst = declare_device(
        '_Z30nvshmemi_schar_put_signal_warpPaPKamPmmiib_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z30nvshmemi_schar_put_signal_warpPaPKamPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z30nvshmemi_schar_put_signal_warpPaPKamPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_schar_put_signal_warp, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemi_schar_put_signal_warpPaPKamPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemi_schar_put_signal_warpPaPKamPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z30nvshmemi_schar_put_signal_warpPaPKamPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_int_put_signal_warp():
    pass
    

def _lower__Z28nvshmemi_int_put_signal_warpPiPKimPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemi_int_put_signal_warpPiPKimPmmiib_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_int_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z28nvshmemi_int_put_signal_warpPiPKimPmmiib_nbst = declare_device(
        '_Z28nvshmemi_int_put_signal_warpPiPKimPmmiib_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z28nvshmemi_int_put_signal_warpPiPKimPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z28nvshmemi_int_put_signal_warpPiPKimPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_int_put_signal_warp, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemi_int_put_signal_warpPiPKimPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemi_int_put_signal_warpPiPKimPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z28nvshmemi_int_put_signal_warpPiPKimPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_long_put_signal_warp():
    pass
    

def _lower__Z29nvshmemi_long_put_signal_warpPlPKlmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemi_long_put_signal_warpPlPKlmPmmiib_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_long_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z29nvshmemi_long_put_signal_warpPlPKlmPmmiib_nbst = declare_device(
        '_Z29nvshmemi_long_put_signal_warpPlPKlmPmmiib_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z29nvshmemi_long_put_signal_warpPlPKlmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z29nvshmemi_long_put_signal_warpPlPKlmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_long_put_signal_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemi_long_put_signal_warpPlPKlmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemi_long_put_signal_warpPlPKlmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z29nvshmemi_long_put_signal_warpPlPKlmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_longlong_put_signal_warp():
    pass
    

def _lower__Z33nvshmemi_longlong_put_signal_warpPxPKxmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemi_longlong_put_signal_warpPxPKxmPmmiib_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_longlong_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z33nvshmemi_longlong_put_signal_warpPxPKxmPmmiib_nbst = declare_device(
        '_Z33nvshmemi_longlong_put_signal_warpPxPKxmPmmiib_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z33nvshmemi_longlong_put_signal_warpPxPKxmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemi_longlong_put_signal_warpPxPKxmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_longlong_put_signal_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemi_longlong_put_signal_warpPxPKxmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemi_longlong_put_signal_warpPxPKxmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z33nvshmemi_longlong_put_signal_warpPxPKxmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_uchar_put_signal_warp():
    pass
    

def _lower__Z30nvshmemi_uchar_put_signal_warpPhPKhmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemi_uchar_put_signal_warpPhPKhmPmmiib_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_uchar_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z30nvshmemi_uchar_put_signal_warpPhPKhmPmmiib_nbst = declare_device(
        '_Z30nvshmemi_uchar_put_signal_warpPhPKhmPmmiib_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z30nvshmemi_uchar_put_signal_warpPhPKhmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z30nvshmemi_uchar_put_signal_warpPhPKhmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_uchar_put_signal_warp, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemi_uchar_put_signal_warpPhPKhmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemi_uchar_put_signal_warpPhPKhmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z30nvshmemi_uchar_put_signal_warpPhPKhmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_ushort_put_signal_warp():
    pass
    

def _lower__Z31nvshmemi_ushort_put_signal_warpPtPKtmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemi_ushort_put_signal_warpPtPKtmPmmiib_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_ushort_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z31nvshmemi_ushort_put_signal_warpPtPKtmPmmiib_nbst = declare_device(
        '_Z31nvshmemi_ushort_put_signal_warpPtPKtmPmmiib_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z31nvshmemi_ushort_put_signal_warpPtPKtmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemi_ushort_put_signal_warpPtPKtmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_ushort_put_signal_warp, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemi_ushort_put_signal_warpPtPKtmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemi_ushort_put_signal_warpPtPKtmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z31nvshmemi_ushort_put_signal_warpPtPKtmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_uint_put_signal_warp():
    pass
    

def _lower__Z29nvshmemi_uint_put_signal_warpPjPKjmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemi_uint_put_signal_warpPjPKjmPmmiib_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_uint_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z29nvshmemi_uint_put_signal_warpPjPKjmPmmiib_nbst = declare_device(
        '_Z29nvshmemi_uint_put_signal_warpPjPKjmPmmiib_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z29nvshmemi_uint_put_signal_warpPjPKjmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z29nvshmemi_uint_put_signal_warpPjPKjmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_uint_put_signal_warp, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemi_uint_put_signal_warpPjPKjmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemi_uint_put_signal_warpPjPKjmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z29nvshmemi_uint_put_signal_warpPjPKjmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_ulong_put_signal_warp():
    pass
    

def _lower__Z30nvshmemi_ulong_put_signal_warpPmPKmmS_miib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemi_ulong_put_signal_warpPmPKmmS_miib_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_ulong_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z30nvshmemi_ulong_put_signal_warpPmPKmmS_miib_nbst = declare_device(
        '_Z30nvshmemi_ulong_put_signal_warpPmPKmmS_miib_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z30nvshmemi_ulong_put_signal_warpPmPKmmS_miib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z30nvshmemi_ulong_put_signal_warpPmPKmmS_miib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_ulong_put_signal_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemi_ulong_put_signal_warpPmPKmmS_miib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemi_ulong_put_signal_warpPmPKmmS_miib_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z30nvshmemi_ulong_put_signal_warpPmPKmmS_miib_nbst(shim_stream, shim_obj)


def nvshmemi_ulonglong_put_signal_warp():
    pass
    

def _lower__Z34nvshmemi_ulonglong_put_signal_warpPyPKymPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemi_ulonglong_put_signal_warpPyPKymPmmiib_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_ulonglong_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z34nvshmemi_ulonglong_put_signal_warpPyPKymPmmiib_nbst = declare_device(
        '_Z34nvshmemi_ulonglong_put_signal_warpPyPKymPmmiib_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z34nvshmemi_ulonglong_put_signal_warpPyPKymPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z34nvshmemi_ulonglong_put_signal_warpPyPKymPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_ulonglong_put_signal_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemi_ulonglong_put_signal_warpPyPKymPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemi_ulonglong_put_signal_warpPyPKymPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z34nvshmemi_ulonglong_put_signal_warpPyPKymPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_int8_put_signal_warp():
    pass
    

def _lower__Z29nvshmemi_int8_put_signal_warpPaPKamPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemi_int8_put_signal_warpPaPKamPmmiib_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_int8_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z29nvshmemi_int8_put_signal_warpPaPKamPmmiib_nbst = declare_device(
        '_Z29nvshmemi_int8_put_signal_warpPaPKamPmmiib_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z29nvshmemi_int8_put_signal_warpPaPKamPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z29nvshmemi_int8_put_signal_warpPaPKamPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_int8_put_signal_warp, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemi_int8_put_signal_warpPaPKamPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemi_int8_put_signal_warpPaPKamPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z29nvshmemi_int8_put_signal_warpPaPKamPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_int16_put_signal_warp():
    pass
    

def _lower__Z30nvshmemi_int16_put_signal_warpPsPKsmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemi_int16_put_signal_warpPsPKsmPmmiib_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_int16_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z30nvshmemi_int16_put_signal_warpPsPKsmPmmiib_nbst = declare_device(
        '_Z30nvshmemi_int16_put_signal_warpPsPKsmPmmiib_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z30nvshmemi_int16_put_signal_warpPsPKsmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z30nvshmemi_int16_put_signal_warpPsPKsmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_int16_put_signal_warp, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemi_int16_put_signal_warpPsPKsmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemi_int16_put_signal_warpPsPKsmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z30nvshmemi_int16_put_signal_warpPsPKsmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_int32_put_signal_warp():
    pass
    

def _lower__Z30nvshmemi_int32_put_signal_warpPiPKimPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemi_int32_put_signal_warpPiPKimPmmiib_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_int32_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z30nvshmemi_int32_put_signal_warpPiPKimPmmiib_nbst = declare_device(
        '_Z30nvshmemi_int32_put_signal_warpPiPKimPmmiib_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z30nvshmemi_int32_put_signal_warpPiPKimPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z30nvshmemi_int32_put_signal_warpPiPKimPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_int32_put_signal_warp, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemi_int32_put_signal_warpPiPKimPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemi_int32_put_signal_warpPiPKimPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z30nvshmemi_int32_put_signal_warpPiPKimPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_int64_put_signal_warp():
    pass
    

def _lower__Z30nvshmemi_int64_put_signal_warpPlPKlmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemi_int64_put_signal_warpPlPKlmPmmiib_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_int64_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z30nvshmemi_int64_put_signal_warpPlPKlmPmmiib_nbst = declare_device(
        '_Z30nvshmemi_int64_put_signal_warpPlPKlmPmmiib_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z30nvshmemi_int64_put_signal_warpPlPKlmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z30nvshmemi_int64_put_signal_warpPlPKlmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_int64_put_signal_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemi_int64_put_signal_warpPlPKlmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemi_int64_put_signal_warpPlPKlmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z30nvshmemi_int64_put_signal_warpPlPKlmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_uint8_put_signal_warp():
    pass
    

def _lower__Z30nvshmemi_uint8_put_signal_warpPhPKhmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemi_uint8_put_signal_warpPhPKhmPmmiib_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_uint8_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z30nvshmemi_uint8_put_signal_warpPhPKhmPmmiib_nbst = declare_device(
        '_Z30nvshmemi_uint8_put_signal_warpPhPKhmPmmiib_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z30nvshmemi_uint8_put_signal_warpPhPKhmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z30nvshmemi_uint8_put_signal_warpPhPKhmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_uint8_put_signal_warp, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemi_uint8_put_signal_warpPhPKhmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemi_uint8_put_signal_warpPhPKhmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z30nvshmemi_uint8_put_signal_warpPhPKhmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_uint16_put_signal_warp():
    pass
    

def _lower__Z31nvshmemi_uint16_put_signal_warpPtPKtmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemi_uint16_put_signal_warpPtPKtmPmmiib_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_uint16_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z31nvshmemi_uint16_put_signal_warpPtPKtmPmmiib_nbst = declare_device(
        '_Z31nvshmemi_uint16_put_signal_warpPtPKtmPmmiib_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z31nvshmemi_uint16_put_signal_warpPtPKtmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemi_uint16_put_signal_warpPtPKtmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_uint16_put_signal_warp, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemi_uint16_put_signal_warpPtPKtmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemi_uint16_put_signal_warpPtPKtmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z31nvshmemi_uint16_put_signal_warpPtPKtmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_uint32_put_signal_warp():
    pass
    

def _lower__Z31nvshmemi_uint32_put_signal_warpPjPKjmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemi_uint32_put_signal_warpPjPKjmPmmiib_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_uint32_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z31nvshmemi_uint32_put_signal_warpPjPKjmPmmiib_nbst = declare_device(
        '_Z31nvshmemi_uint32_put_signal_warpPjPKjmPmmiib_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z31nvshmemi_uint32_put_signal_warpPjPKjmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemi_uint32_put_signal_warpPjPKjmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_uint32_put_signal_warp, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemi_uint32_put_signal_warpPjPKjmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemi_uint32_put_signal_warpPjPKjmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z31nvshmemi_uint32_put_signal_warpPjPKjmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_uint64_put_signal_warp():
    pass
    

def _lower__Z31nvshmemi_uint64_put_signal_warpPmPKmmS_miib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemi_uint64_put_signal_warpPmPKmmS_miib_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_uint64_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z31nvshmemi_uint64_put_signal_warpPmPKmmS_miib_nbst = declare_device(
        '_Z31nvshmemi_uint64_put_signal_warpPmPKmmS_miib_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z31nvshmemi_uint64_put_signal_warpPmPKmmS_miib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemi_uint64_put_signal_warpPmPKmmS_miib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_uint64_put_signal_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemi_uint64_put_signal_warpPmPKmmS_miib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemi_uint64_put_signal_warpPmPKmmS_miib_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z31nvshmemi_uint64_put_signal_warpPmPKmmS_miib_nbst(shim_stream, shim_obj)


def nvshmemi_size_put_signal_warp():
    pass
    

def _lower__Z29nvshmemi_size_put_signal_warpPmPKmmS_miib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemi_size_put_signal_warpPmPKmmS_miib_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_size_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z29nvshmemi_size_put_signal_warpPmPKmmS_miib_nbst = declare_device(
        '_Z29nvshmemi_size_put_signal_warpPmPKmmS_miib_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z29nvshmemi_size_put_signal_warpPmPKmmS_miib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z29nvshmemi_size_put_signal_warpPmPKmmS_miib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_size_put_signal_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemi_size_put_signal_warpPmPKmmS_miib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemi_size_put_signal_warpPmPKmmS_miib_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z29nvshmemi_size_put_signal_warpPmPKmmS_miib_nbst(shim_stream, shim_obj)


def nvshmemi_ptrdiff_put_signal_warp():
    pass
    

def _lower__Z32nvshmemi_ptrdiff_put_signal_warpPlPKlmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemi_ptrdiff_put_signal_warpPlPKlmPmmiib_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_ptrdiff_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z32nvshmemi_ptrdiff_put_signal_warpPlPKlmPmmiib_nbst = declare_device(
        '_Z32nvshmemi_ptrdiff_put_signal_warpPlPKlmPmmiib_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z32nvshmemi_ptrdiff_put_signal_warpPlPKlmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemi_ptrdiff_put_signal_warpPlPKlmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_ptrdiff_put_signal_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemi_ptrdiff_put_signal_warpPlPKlmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemi_ptrdiff_put_signal_warpPlPKlmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z32nvshmemi_ptrdiff_put_signal_warpPlPKlmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_bfloat16_put_signal_block():
    pass
    

def _lower__Z34nvshmemi_bfloat16_put_signal_blockP13__nv_bfloat16PKS_mPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemi_bfloat16_put_signal_blockP13__nv_bfloat16PKS_mPmmiib_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_bfloat16_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z34nvshmemi_bfloat16_put_signal_blockP13__nv_bfloat16PKS_mPmmiib_nbst = declare_device(
        '_Z34nvshmemi_bfloat16_put_signal_blockP13__nv_bfloat16PKS_mPmmiib_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z34nvshmemi_bfloat16_put_signal_blockP13__nv_bfloat16PKS_mPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z34nvshmemi_bfloat16_put_signal_blockP13__nv_bfloat16PKS_mPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_bfloat16_put_signal_block, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemi_bfloat16_put_signal_blockP13__nv_bfloat16PKS_mPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemi_bfloat16_put_signal_blockP13__nv_bfloat16PKS_mPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z34nvshmemi_bfloat16_put_signal_blockP13__nv_bfloat16PKS_mPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_half_put_signal_block():
    pass
    

def _lower__Z30nvshmemi_half_put_signal_blockP6__halfPKS_mPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemi_half_put_signal_blockP6__halfPKS_mPmmiib_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_half_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z30nvshmemi_half_put_signal_blockP6__halfPKS_mPmmiib_nbst = declare_device(
        '_Z30nvshmemi_half_put_signal_blockP6__halfPKS_mPmmiib_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z30nvshmemi_half_put_signal_blockP6__halfPKS_mPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z30nvshmemi_half_put_signal_blockP6__halfPKS_mPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_half_put_signal_block, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemi_half_put_signal_blockP6__halfPKS_mPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemi_half_put_signal_blockP6__halfPKS_mPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z30nvshmemi_half_put_signal_blockP6__halfPKS_mPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_float_put_signal_block():
    pass
    

def _lower__Z31nvshmemi_float_put_signal_blockPfPKfmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemi_float_put_signal_blockPfPKfmPmmiib_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_float_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z31nvshmemi_float_put_signal_blockPfPKfmPmmiib_nbst = declare_device(
        '_Z31nvshmemi_float_put_signal_blockPfPKfmPmmiib_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z31nvshmemi_float_put_signal_blockPfPKfmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemi_float_put_signal_blockPfPKfmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_float_put_signal_block, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemi_float_put_signal_blockPfPKfmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemi_float_put_signal_blockPfPKfmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z31nvshmemi_float_put_signal_blockPfPKfmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_double_put_signal_block():
    pass
    

def _lower__Z32nvshmemi_double_put_signal_blockPdPKdmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemi_double_put_signal_blockPdPKdmPmmiib_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_double_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z32nvshmemi_double_put_signal_blockPdPKdmPmmiib_nbst = declare_device(
        '_Z32nvshmemi_double_put_signal_blockPdPKdmPmmiib_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z32nvshmemi_double_put_signal_blockPdPKdmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemi_double_put_signal_blockPdPKdmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_double_put_signal_block, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemi_double_put_signal_blockPdPKdmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemi_double_put_signal_blockPdPKdmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z32nvshmemi_double_put_signal_blockPdPKdmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_char_put_signal_block():
    pass
    

def _lower__Z30nvshmemi_char_put_signal_blockPcPKcmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemi_char_put_signal_blockPcPKcmPmmiib_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_char_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z30nvshmemi_char_put_signal_blockPcPKcmPmmiib_nbst = declare_device(
        '_Z30nvshmemi_char_put_signal_blockPcPKcmPmmiib_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z30nvshmemi_char_put_signal_blockPcPKcmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z30nvshmemi_char_put_signal_blockPcPKcmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_char_put_signal_block, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemi_char_put_signal_blockPcPKcmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemi_char_put_signal_blockPcPKcmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z30nvshmemi_char_put_signal_blockPcPKcmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_short_put_signal_block():
    pass
    

def _lower__Z31nvshmemi_short_put_signal_blockPsPKsmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemi_short_put_signal_blockPsPKsmPmmiib_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_short_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z31nvshmemi_short_put_signal_blockPsPKsmPmmiib_nbst = declare_device(
        '_Z31nvshmemi_short_put_signal_blockPsPKsmPmmiib_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z31nvshmemi_short_put_signal_blockPsPKsmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemi_short_put_signal_blockPsPKsmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_short_put_signal_block, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemi_short_put_signal_blockPsPKsmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemi_short_put_signal_blockPsPKsmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z31nvshmemi_short_put_signal_blockPsPKsmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_schar_put_signal_block():
    pass
    

def _lower__Z31nvshmemi_schar_put_signal_blockPaPKamPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemi_schar_put_signal_blockPaPKamPmmiib_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_schar_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z31nvshmemi_schar_put_signal_blockPaPKamPmmiib_nbst = declare_device(
        '_Z31nvshmemi_schar_put_signal_blockPaPKamPmmiib_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z31nvshmemi_schar_put_signal_blockPaPKamPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemi_schar_put_signal_blockPaPKamPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_schar_put_signal_block, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemi_schar_put_signal_blockPaPKamPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemi_schar_put_signal_blockPaPKamPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z31nvshmemi_schar_put_signal_blockPaPKamPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_int_put_signal_block():
    pass
    

def _lower__Z29nvshmemi_int_put_signal_blockPiPKimPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemi_int_put_signal_blockPiPKimPmmiib_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_int_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z29nvshmemi_int_put_signal_blockPiPKimPmmiib_nbst = declare_device(
        '_Z29nvshmemi_int_put_signal_blockPiPKimPmmiib_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z29nvshmemi_int_put_signal_blockPiPKimPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z29nvshmemi_int_put_signal_blockPiPKimPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_int_put_signal_block, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemi_int_put_signal_blockPiPKimPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemi_int_put_signal_blockPiPKimPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z29nvshmemi_int_put_signal_blockPiPKimPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_long_put_signal_block():
    pass
    

def _lower__Z30nvshmemi_long_put_signal_blockPlPKlmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemi_long_put_signal_blockPlPKlmPmmiib_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_long_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z30nvshmemi_long_put_signal_blockPlPKlmPmmiib_nbst = declare_device(
        '_Z30nvshmemi_long_put_signal_blockPlPKlmPmmiib_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z30nvshmemi_long_put_signal_blockPlPKlmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z30nvshmemi_long_put_signal_blockPlPKlmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_long_put_signal_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemi_long_put_signal_blockPlPKlmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemi_long_put_signal_blockPlPKlmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z30nvshmemi_long_put_signal_blockPlPKlmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_longlong_put_signal_block():
    pass
    

def _lower__Z34nvshmemi_longlong_put_signal_blockPxPKxmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemi_longlong_put_signal_blockPxPKxmPmmiib_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_longlong_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z34nvshmemi_longlong_put_signal_blockPxPKxmPmmiib_nbst = declare_device(
        '_Z34nvshmemi_longlong_put_signal_blockPxPKxmPmmiib_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z34nvshmemi_longlong_put_signal_blockPxPKxmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z34nvshmemi_longlong_put_signal_blockPxPKxmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_longlong_put_signal_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemi_longlong_put_signal_blockPxPKxmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemi_longlong_put_signal_blockPxPKxmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z34nvshmemi_longlong_put_signal_blockPxPKxmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_uchar_put_signal_block():
    pass
    

def _lower__Z31nvshmemi_uchar_put_signal_blockPhPKhmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemi_uchar_put_signal_blockPhPKhmPmmiib_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_uchar_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z31nvshmemi_uchar_put_signal_blockPhPKhmPmmiib_nbst = declare_device(
        '_Z31nvshmemi_uchar_put_signal_blockPhPKhmPmmiib_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z31nvshmemi_uchar_put_signal_blockPhPKhmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemi_uchar_put_signal_blockPhPKhmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_uchar_put_signal_block, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemi_uchar_put_signal_blockPhPKhmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemi_uchar_put_signal_blockPhPKhmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z31nvshmemi_uchar_put_signal_blockPhPKhmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_ushort_put_signal_block():
    pass
    

def _lower__Z32nvshmemi_ushort_put_signal_blockPtPKtmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemi_ushort_put_signal_blockPtPKtmPmmiib_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_ushort_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z32nvshmemi_ushort_put_signal_blockPtPKtmPmmiib_nbst = declare_device(
        '_Z32nvshmemi_ushort_put_signal_blockPtPKtmPmmiib_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z32nvshmemi_ushort_put_signal_blockPtPKtmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemi_ushort_put_signal_blockPtPKtmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_ushort_put_signal_block, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemi_ushort_put_signal_blockPtPKtmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemi_ushort_put_signal_blockPtPKtmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z32nvshmemi_ushort_put_signal_blockPtPKtmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_uint_put_signal_block():
    pass
    

def _lower__Z30nvshmemi_uint_put_signal_blockPjPKjmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemi_uint_put_signal_blockPjPKjmPmmiib_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_uint_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z30nvshmemi_uint_put_signal_blockPjPKjmPmmiib_nbst = declare_device(
        '_Z30nvshmemi_uint_put_signal_blockPjPKjmPmmiib_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z30nvshmemi_uint_put_signal_blockPjPKjmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z30nvshmemi_uint_put_signal_blockPjPKjmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_uint_put_signal_block, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemi_uint_put_signal_blockPjPKjmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemi_uint_put_signal_blockPjPKjmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z30nvshmemi_uint_put_signal_blockPjPKjmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_ulong_put_signal_block():
    pass
    

def _lower__Z31nvshmemi_ulong_put_signal_blockPmPKmmS_miib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemi_ulong_put_signal_blockPmPKmmS_miib_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_ulong_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z31nvshmemi_ulong_put_signal_blockPmPKmmS_miib_nbst = declare_device(
        '_Z31nvshmemi_ulong_put_signal_blockPmPKmmS_miib_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z31nvshmemi_ulong_put_signal_blockPmPKmmS_miib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemi_ulong_put_signal_blockPmPKmmS_miib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_ulong_put_signal_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemi_ulong_put_signal_blockPmPKmmS_miib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemi_ulong_put_signal_blockPmPKmmS_miib_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z31nvshmemi_ulong_put_signal_blockPmPKmmS_miib_nbst(shim_stream, shim_obj)


def nvshmemi_ulonglong_put_signal_block():
    pass
    

def _lower__Z35nvshmemi_ulonglong_put_signal_blockPyPKymPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemi_ulonglong_put_signal_blockPyPKymPmmiib_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_ulonglong_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z35nvshmemi_ulonglong_put_signal_blockPyPKymPmmiib_nbst = declare_device(
        '_Z35nvshmemi_ulonglong_put_signal_blockPyPKymPmmiib_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z35nvshmemi_ulonglong_put_signal_blockPyPKymPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z35nvshmemi_ulonglong_put_signal_blockPyPKymPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_ulonglong_put_signal_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemi_ulonglong_put_signal_blockPyPKymPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemi_ulonglong_put_signal_blockPyPKymPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z35nvshmemi_ulonglong_put_signal_blockPyPKymPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_int8_put_signal_block():
    pass
    

def _lower__Z30nvshmemi_int8_put_signal_blockPaPKamPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemi_int8_put_signal_blockPaPKamPmmiib_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_int8_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z30nvshmemi_int8_put_signal_blockPaPKamPmmiib_nbst = declare_device(
        '_Z30nvshmemi_int8_put_signal_blockPaPKamPmmiib_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z30nvshmemi_int8_put_signal_blockPaPKamPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z30nvshmemi_int8_put_signal_blockPaPKamPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_int8_put_signal_block, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemi_int8_put_signal_blockPaPKamPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemi_int8_put_signal_blockPaPKamPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z30nvshmemi_int8_put_signal_blockPaPKamPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_int16_put_signal_block():
    pass
    

def _lower__Z31nvshmemi_int16_put_signal_blockPsPKsmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemi_int16_put_signal_blockPsPKsmPmmiib_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_int16_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z31nvshmemi_int16_put_signal_blockPsPKsmPmmiib_nbst = declare_device(
        '_Z31nvshmemi_int16_put_signal_blockPsPKsmPmmiib_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z31nvshmemi_int16_put_signal_blockPsPKsmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemi_int16_put_signal_blockPsPKsmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_int16_put_signal_block, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemi_int16_put_signal_blockPsPKsmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemi_int16_put_signal_blockPsPKsmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z31nvshmemi_int16_put_signal_blockPsPKsmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_int32_put_signal_block():
    pass
    

def _lower__Z31nvshmemi_int32_put_signal_blockPiPKimPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemi_int32_put_signal_blockPiPKimPmmiib_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_int32_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z31nvshmemi_int32_put_signal_blockPiPKimPmmiib_nbst = declare_device(
        '_Z31nvshmemi_int32_put_signal_blockPiPKimPmmiib_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z31nvshmemi_int32_put_signal_blockPiPKimPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemi_int32_put_signal_blockPiPKimPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_int32_put_signal_block, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemi_int32_put_signal_blockPiPKimPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemi_int32_put_signal_blockPiPKimPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z31nvshmemi_int32_put_signal_blockPiPKimPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_int64_put_signal_block():
    pass
    

def _lower__Z31nvshmemi_int64_put_signal_blockPlPKlmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemi_int64_put_signal_blockPlPKlmPmmiib_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_int64_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z31nvshmemi_int64_put_signal_blockPlPKlmPmmiib_nbst = declare_device(
        '_Z31nvshmemi_int64_put_signal_blockPlPKlmPmmiib_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z31nvshmemi_int64_put_signal_blockPlPKlmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemi_int64_put_signal_blockPlPKlmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_int64_put_signal_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemi_int64_put_signal_blockPlPKlmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemi_int64_put_signal_blockPlPKlmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z31nvshmemi_int64_put_signal_blockPlPKlmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_uint8_put_signal_block():
    pass
    

def _lower__Z31nvshmemi_uint8_put_signal_blockPhPKhmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemi_uint8_put_signal_blockPhPKhmPmmiib_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_uint8_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z31nvshmemi_uint8_put_signal_blockPhPKhmPmmiib_nbst = declare_device(
        '_Z31nvshmemi_uint8_put_signal_blockPhPKhmPmmiib_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z31nvshmemi_uint8_put_signal_blockPhPKhmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemi_uint8_put_signal_blockPhPKhmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_uint8_put_signal_block, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemi_uint8_put_signal_blockPhPKhmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemi_uint8_put_signal_blockPhPKhmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z31nvshmemi_uint8_put_signal_blockPhPKhmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_uint16_put_signal_block():
    pass
    

def _lower__Z32nvshmemi_uint16_put_signal_blockPtPKtmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemi_uint16_put_signal_blockPtPKtmPmmiib_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_uint16_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z32nvshmemi_uint16_put_signal_blockPtPKtmPmmiib_nbst = declare_device(
        '_Z32nvshmemi_uint16_put_signal_blockPtPKtmPmmiib_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z32nvshmemi_uint16_put_signal_blockPtPKtmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemi_uint16_put_signal_blockPtPKtmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_uint16_put_signal_block, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemi_uint16_put_signal_blockPtPKtmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemi_uint16_put_signal_blockPtPKtmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z32nvshmemi_uint16_put_signal_blockPtPKtmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_uint32_put_signal_block():
    pass
    

def _lower__Z32nvshmemi_uint32_put_signal_blockPjPKjmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemi_uint32_put_signal_blockPjPKjmPmmiib_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_uint32_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z32nvshmemi_uint32_put_signal_blockPjPKjmPmmiib_nbst = declare_device(
        '_Z32nvshmemi_uint32_put_signal_blockPjPKjmPmmiib_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z32nvshmemi_uint32_put_signal_blockPjPKjmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemi_uint32_put_signal_blockPjPKjmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_uint32_put_signal_block, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemi_uint32_put_signal_blockPjPKjmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemi_uint32_put_signal_blockPjPKjmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z32nvshmemi_uint32_put_signal_blockPjPKjmPmmiib_nbst(shim_stream, shim_obj)


def nvshmemi_uint64_put_signal_block():
    pass
    

def _lower__Z32nvshmemi_uint64_put_signal_blockPmPKmmS_miib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemi_uint64_put_signal_blockPmPKmmS_miib_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_uint64_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z32nvshmemi_uint64_put_signal_blockPmPKmmS_miib_nbst = declare_device(
        '_Z32nvshmemi_uint64_put_signal_blockPmPKmmS_miib_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z32nvshmemi_uint64_put_signal_blockPmPKmmS_miib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemi_uint64_put_signal_blockPmPKmmS_miib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_uint64_put_signal_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemi_uint64_put_signal_blockPmPKmmS_miib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemi_uint64_put_signal_blockPmPKmmS_miib_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z32nvshmemi_uint64_put_signal_blockPmPKmmS_miib_nbst(shim_stream, shim_obj)


def nvshmemi_size_put_signal_block():
    pass
    

def _lower__Z30nvshmemi_size_put_signal_blockPmPKmmS_miib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemi_size_put_signal_blockPmPKmmS_miib_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_size_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z30nvshmemi_size_put_signal_blockPmPKmmS_miib_nbst = declare_device(
        '_Z30nvshmemi_size_put_signal_blockPmPKmmS_miib_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z30nvshmemi_size_put_signal_blockPmPKmmS_miib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z30nvshmemi_size_put_signal_blockPmPKmmS_miib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_size_put_signal_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemi_size_put_signal_blockPmPKmmS_miib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemi_size_put_signal_blockPmPKmmS_miib_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z30nvshmemi_size_put_signal_blockPmPKmmS_miib_nbst(shim_stream, shim_obj)


def nvshmemi_ptrdiff_put_signal_block():
    pass
    

def _lower__Z33nvshmemi_ptrdiff_put_signal_blockPlPKlmPmmiib_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemi_ptrdiff_put_signal_blockPlPKlmPmmiib_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, bool* is_nbi) {
        nvshmemi_ptrdiff_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *is_nbi);
        return 0;
    }
        """


    _Z33nvshmemi_ptrdiff_put_signal_blockPlPKlmPmmiib_nbst = declare_device(
        '_Z33nvshmemi_ptrdiff_put_signal_blockPlPKlmPmmiib_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)
        )
    )
    

    def _Z33nvshmemi_ptrdiff_put_signal_blockPlPKlmPmmiib_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemi_ptrdiff_put_signal_blockPlPKlmPmmiib_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(nvshmemi_ptrdiff_put_signal_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, bool_)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemi_ptrdiff_put_signal_blockPlPKlmPmmiib_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemi_ptrdiff_put_signal_blockPlPKlmPmmiib_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(bool_)),
            ptrs,
        )



_lower__Z33nvshmemi_ptrdiff_put_signal_blockPlPKlmPmmiib_nbst(shim_stream, shim_obj)


def bfloat16_put_signal_warp():
    pass
    

def _lower__Z33nvshmemx_bfloat16_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_bfloat16_put_signal_warp_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_bfloat16_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z33nvshmemx_bfloat16_put_signal_warp_nbst = declare_device(
        '_Z33nvshmemx_bfloat16_put_signal_warp_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_bfloat16_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z33nvshmemx_bfloat16_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(bfloat16_put_signal_warp, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_bfloat16_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_bfloat16_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_bfloat16_put_signal_warp_nbst(shim_stream, shim_obj)


def half_put_signal_warp():
    pass
    

def _lower__Z29nvshmemx_half_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_half_put_signal_warp_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_half_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_half_put_signal_warp_nbst = declare_device(
        '_Z29nvshmemx_half_put_signal_warp_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_half_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z29nvshmemx_half_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(half_put_signal_warp, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_half_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_half_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_half_put_signal_warp_nbst(shim_stream, shim_obj)


def float_put_signal_warp():
    pass
    

def _lower__Z30nvshmemx_float_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_float_put_signal_warp_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_float_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_float_put_signal_warp_nbst = declare_device(
        '_Z30nvshmemx_float_put_signal_warp_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_float_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmemx_float_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(float_put_signal_warp, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_float_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_float_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_float_put_signal_warp_nbst(shim_stream, shim_obj)


def double_put_signal_warp():
    pass
    

def _lower__Z31nvshmemx_double_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_double_put_signal_warp_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_double_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_double_put_signal_warp_nbst = declare_device(
        '_Z31nvshmemx_double_put_signal_warp_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_double_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmemx_double_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(double_put_signal_warp, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_double_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_double_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_double_put_signal_warp_nbst(shim_stream, shim_obj)


def char_put_signal_warp():
    pass
    

def _lower__Z29nvshmemx_char_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_char_put_signal_warp_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_char_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_char_put_signal_warp_nbst = declare_device(
        '_Z29nvshmemx_char_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_char_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z29nvshmemx_char_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(char_put_signal_warp, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_char_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_char_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_char_put_signal_warp_nbst(shim_stream, shim_obj)


def short_put_signal_warp():
    pass
    

def _lower__Z30nvshmemx_short_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_short_put_signal_warp_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_short_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_short_put_signal_warp_nbst = declare_device(
        '_Z30nvshmemx_short_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_short_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmemx_short_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(short_put_signal_warp, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_short_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_short_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_short_put_signal_warp_nbst(shim_stream, shim_obj)


def schar_put_signal_warp():
    pass
    

def _lower__Z30nvshmemx_schar_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_schar_put_signal_warp_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_schar_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_schar_put_signal_warp_nbst = declare_device(
        '_Z30nvshmemx_schar_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_schar_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmemx_schar_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(schar_put_signal_warp, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_schar_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_schar_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_schar_put_signal_warp_nbst(shim_stream, shim_obj)


def int_put_signal_warp():
    pass
    

def _lower__Z28nvshmemx_int_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_int_put_signal_warp_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_int_put_signal_warp_nbst = declare_device(
        '_Z28nvshmemx_int_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_int_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z28nvshmemx_int_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int_put_signal_warp, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_int_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_int_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_int_put_signal_warp_nbst(shim_stream, shim_obj)


def long_put_signal_warp():
    pass
    

def _lower__Z29nvshmemx_long_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_long_put_signal_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_long_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_long_put_signal_warp_nbst = declare_device(
        '_Z29nvshmemx_long_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_long_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z29nvshmemx_long_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(long_put_signal_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_long_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_long_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_long_put_signal_warp_nbst(shim_stream, shim_obj)


def longlong_put_signal_warp():
    pass
    

def _lower__Z33nvshmemx_longlong_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_longlong_put_signal_warp_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_longlong_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z33nvshmemx_longlong_put_signal_warp_nbst = declare_device(
        '_Z33nvshmemx_longlong_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_longlong_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z33nvshmemx_longlong_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(longlong_put_signal_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_longlong_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_longlong_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_longlong_put_signal_warp_nbst(shim_stream, shim_obj)


def uchar_put_signal_warp():
    pass
    

def _lower__Z30nvshmemx_uchar_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_uchar_put_signal_warp_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uchar_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_uchar_put_signal_warp_nbst = declare_device(
        '_Z30nvshmemx_uchar_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_uchar_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmemx_uchar_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uchar_put_signal_warp, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_uchar_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_uchar_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_uchar_put_signal_warp_nbst(shim_stream, shim_obj)


def ushort_put_signal_warp():
    pass
    

def _lower__Z31nvshmemx_ushort_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_ushort_put_signal_warp_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_ushort_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_ushort_put_signal_warp_nbst = declare_device(
        '_Z31nvshmemx_ushort_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_ushort_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmemx_ushort_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ushort_put_signal_warp, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_ushort_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_ushort_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_ushort_put_signal_warp_nbst(shim_stream, shim_obj)


def uint_put_signal_warp():
    pass
    

def _lower__Z29nvshmemx_uint_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_uint_put_signal_warp_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_uint_put_signal_warp_nbst = declare_device(
        '_Z29nvshmemx_uint_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_uint_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z29nvshmemx_uint_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint_put_signal_warp, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_uint_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_uint_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_uint_put_signal_warp_nbst(shim_stream, shim_obj)


def ulong_put_signal_warp():
    pass
    

def _lower__Z30nvshmemx_ulong_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_ulong_put_signal_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_ulong_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_ulong_put_signal_warp_nbst = declare_device(
        '_Z30nvshmemx_ulong_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_ulong_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmemx_ulong_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ulong_put_signal_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_ulong_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_ulong_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_ulong_put_signal_warp_nbst(shim_stream, shim_obj)


def ulonglong_put_signal_warp():
    pass
    

def _lower__Z34nvshmemx_ulonglong_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_ulonglong_put_signal_warp_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_ulonglong_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z34nvshmemx_ulonglong_put_signal_warp_nbst = declare_device(
        '_Z34nvshmemx_ulonglong_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_ulonglong_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z34nvshmemx_ulonglong_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ulonglong_put_signal_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_ulonglong_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_ulonglong_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_ulonglong_put_signal_warp_nbst(shim_stream, shim_obj)


def int8_put_signal_warp():
    pass
    

def _lower__Z29nvshmemx_int8_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_int8_put_signal_warp_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int8_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_int8_put_signal_warp_nbst = declare_device(
        '_Z29nvshmemx_int8_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_int8_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z29nvshmemx_int8_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int8_put_signal_warp, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_int8_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_int8_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_int8_put_signal_warp_nbst(shim_stream, shim_obj)


def int16_put_signal_warp():
    pass
    

def _lower__Z30nvshmemx_int16_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_int16_put_signal_warp_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int16_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_int16_put_signal_warp_nbst = declare_device(
        '_Z30nvshmemx_int16_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_int16_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmemx_int16_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int16_put_signal_warp, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_int16_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_int16_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_int16_put_signal_warp_nbst(shim_stream, shim_obj)


def int32_put_signal_warp():
    pass
    

def _lower__Z30nvshmemx_int32_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_int32_put_signal_warp_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int32_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_int32_put_signal_warp_nbst = declare_device(
        '_Z30nvshmemx_int32_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_int32_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmemx_int32_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int32_put_signal_warp, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_int32_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_int32_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_int32_put_signal_warp_nbst(shim_stream, shim_obj)


def int64_put_signal_warp():
    pass
    

def _lower__Z30nvshmemx_int64_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_int64_put_signal_warp_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int64_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_int64_put_signal_warp_nbst = declare_device(
        '_Z30nvshmemx_int64_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_int64_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmemx_int64_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int64_put_signal_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_int64_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_int64_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_int64_put_signal_warp_nbst(shim_stream, shim_obj)


def uint8_put_signal_warp():
    pass
    

def _lower__Z30nvshmemx_uint8_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_uint8_put_signal_warp_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint8_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_uint8_put_signal_warp_nbst = declare_device(
        '_Z30nvshmemx_uint8_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_uint8_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmemx_uint8_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint8_put_signal_warp, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_uint8_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_uint8_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_uint8_put_signal_warp_nbst(shim_stream, shim_obj)


def uint16_put_signal_warp():
    pass
    

def _lower__Z31nvshmemx_uint16_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_uint16_put_signal_warp_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint16_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_uint16_put_signal_warp_nbst = declare_device(
        '_Z31nvshmemx_uint16_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_uint16_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmemx_uint16_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint16_put_signal_warp, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_uint16_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_uint16_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_uint16_put_signal_warp_nbst(shim_stream, shim_obj)


def uint32_put_signal_warp():
    pass
    

def _lower__Z31nvshmemx_uint32_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_uint32_put_signal_warp_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint32_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_uint32_put_signal_warp_nbst = declare_device(
        '_Z31nvshmemx_uint32_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_uint32_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmemx_uint32_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint32_put_signal_warp, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_uint32_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_uint32_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_uint32_put_signal_warp_nbst(shim_stream, shim_obj)


def uint64_put_signal_warp():
    pass
    

def _lower__Z31nvshmemx_uint64_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_uint64_put_signal_warp_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint64_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_uint64_put_signal_warp_nbst = declare_device(
        '_Z31nvshmemx_uint64_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_uint64_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmemx_uint64_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint64_put_signal_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_uint64_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_uint64_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_uint64_put_signal_warp_nbst(shim_stream, shim_obj)


def size_put_signal_warp():
    pass
    

def _lower__Z29nvshmemx_size_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_size_put_signal_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_size_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_size_put_signal_warp_nbst = declare_device(
        '_Z29nvshmemx_size_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_size_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z29nvshmemx_size_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(size_put_signal_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_size_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_size_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_size_put_signal_warp_nbst(shim_stream, shim_obj)


def ptrdiff_put_signal_warp():
    pass
    

def _lower__Z32nvshmemx_ptrdiff_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_ptrdiff_put_signal_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_ptrdiff_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z32nvshmemx_ptrdiff_put_signal_warp_nbst = declare_device(
        '_Z32nvshmemx_ptrdiff_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_ptrdiff_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z32nvshmemx_ptrdiff_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ptrdiff_put_signal_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_ptrdiff_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_ptrdiff_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_ptrdiff_put_signal_warp_nbst(shim_stream, shim_obj)


def bfloat16_put_signal_block():
    pass
    

def _lower__Z34nvshmemx_bfloat16_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_bfloat16_put_signal_block_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_bfloat16_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z34nvshmemx_bfloat16_put_signal_block_nbst = declare_device(
        '_Z34nvshmemx_bfloat16_put_signal_block_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_bfloat16_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z34nvshmemx_bfloat16_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(bfloat16_put_signal_block, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_bfloat16_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_bfloat16_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_bfloat16_put_signal_block_nbst(shim_stream, shim_obj)


def half_put_signal_block():
    pass
    

def _lower__Z30nvshmemx_half_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_half_put_signal_block_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_half_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_half_put_signal_block_nbst = declare_device(
        '_Z30nvshmemx_half_put_signal_block_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_half_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmemx_half_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(half_put_signal_block, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_half_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_half_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_half_put_signal_block_nbst(shim_stream, shim_obj)


def float_put_signal_block():
    pass
    

def _lower__Z31nvshmemx_float_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_float_put_signal_block_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_float_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_float_put_signal_block_nbst = declare_device(
        '_Z31nvshmemx_float_put_signal_block_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_float_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmemx_float_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(float_put_signal_block, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_float_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_float_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_float_put_signal_block_nbst(shim_stream, shim_obj)


def double_put_signal_block():
    pass
    

def _lower__Z32nvshmemx_double_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_double_put_signal_block_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_double_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z32nvshmemx_double_put_signal_block_nbst = declare_device(
        '_Z32nvshmemx_double_put_signal_block_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_double_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z32nvshmemx_double_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(double_put_signal_block, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_double_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_double_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_double_put_signal_block_nbst(shim_stream, shim_obj)


def char_put_signal_block():
    pass
    

def _lower__Z30nvshmemx_char_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_char_put_signal_block_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_char_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_char_put_signal_block_nbst = declare_device(
        '_Z30nvshmemx_char_put_signal_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_char_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmemx_char_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(char_put_signal_block, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_char_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_char_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_char_put_signal_block_nbst(shim_stream, shim_obj)


def short_put_signal_block():
    pass
    

def _lower__Z31nvshmemx_short_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_short_put_signal_block_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_short_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_short_put_signal_block_nbst = declare_device(
        '_Z31nvshmemx_short_put_signal_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_short_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmemx_short_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(short_put_signal_block, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_short_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_short_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_short_put_signal_block_nbst(shim_stream, shim_obj)


def schar_put_signal_block():
    pass
    

def _lower__Z31nvshmemx_schar_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_schar_put_signal_block_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_schar_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_schar_put_signal_block_nbst = declare_device(
        '_Z31nvshmemx_schar_put_signal_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_schar_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmemx_schar_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(schar_put_signal_block, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_schar_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_schar_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_schar_put_signal_block_nbst(shim_stream, shim_obj)


def int_put_signal_block():
    pass
    

def _lower__Z29nvshmemx_int_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_int_put_signal_block_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_int_put_signal_block_nbst = declare_device(
        '_Z29nvshmemx_int_put_signal_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_int_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z29nvshmemx_int_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int_put_signal_block, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_int_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_int_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_int_put_signal_block_nbst(shim_stream, shim_obj)


def long_put_signal_block():
    pass
    

def _lower__Z30nvshmemx_long_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_long_put_signal_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_long_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_long_put_signal_block_nbst = declare_device(
        '_Z30nvshmemx_long_put_signal_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_long_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmemx_long_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(long_put_signal_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_long_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_long_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_long_put_signal_block_nbst(shim_stream, shim_obj)


def longlong_put_signal_block():
    pass
    

def _lower__Z34nvshmemx_longlong_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_longlong_put_signal_block_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_longlong_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z34nvshmemx_longlong_put_signal_block_nbst = declare_device(
        '_Z34nvshmemx_longlong_put_signal_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_longlong_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z34nvshmemx_longlong_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(longlong_put_signal_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_longlong_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_longlong_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_longlong_put_signal_block_nbst(shim_stream, shim_obj)


def uchar_put_signal_block():
    pass
    

def _lower__Z31nvshmemx_uchar_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_uchar_put_signal_block_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uchar_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_uchar_put_signal_block_nbst = declare_device(
        '_Z31nvshmemx_uchar_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_uchar_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmemx_uchar_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uchar_put_signal_block, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_uchar_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_uchar_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_uchar_put_signal_block_nbst(shim_stream, shim_obj)


def ushort_put_signal_block():
    pass
    

def _lower__Z32nvshmemx_ushort_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_ushort_put_signal_block_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_ushort_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z32nvshmemx_ushort_put_signal_block_nbst = declare_device(
        '_Z32nvshmemx_ushort_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_ushort_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z32nvshmemx_ushort_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ushort_put_signal_block, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_ushort_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_ushort_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_ushort_put_signal_block_nbst(shim_stream, shim_obj)


def uint_put_signal_block():
    pass
    

def _lower__Z30nvshmemx_uint_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_uint_put_signal_block_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_uint_put_signal_block_nbst = declare_device(
        '_Z30nvshmemx_uint_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_uint_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmemx_uint_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint_put_signal_block, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_uint_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_uint_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_uint_put_signal_block_nbst(shim_stream, shim_obj)


def ulong_put_signal_block():
    pass
    

def _lower__Z31nvshmemx_ulong_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_ulong_put_signal_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_ulong_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_ulong_put_signal_block_nbst = declare_device(
        '_Z31nvshmemx_ulong_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_ulong_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmemx_ulong_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ulong_put_signal_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_ulong_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_ulong_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_ulong_put_signal_block_nbst(shim_stream, shim_obj)


def ulonglong_put_signal_block():
    pass
    

def _lower__Z35nvshmemx_ulonglong_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_ulonglong_put_signal_block_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_ulonglong_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z35nvshmemx_ulonglong_put_signal_block_nbst = declare_device(
        '_Z35nvshmemx_ulonglong_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_ulonglong_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z35nvshmemx_ulonglong_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ulonglong_put_signal_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_ulonglong_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_ulonglong_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_ulonglong_put_signal_block_nbst(shim_stream, shim_obj)


def int8_put_signal_block():
    pass
    

def _lower__Z30nvshmemx_int8_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_int8_put_signal_block_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int8_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_int8_put_signal_block_nbst = declare_device(
        '_Z30nvshmemx_int8_put_signal_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_int8_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmemx_int8_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int8_put_signal_block, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_int8_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_int8_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_int8_put_signal_block_nbst(shim_stream, shim_obj)


def int16_put_signal_block():
    pass
    

def _lower__Z31nvshmemx_int16_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_int16_put_signal_block_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int16_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_int16_put_signal_block_nbst = declare_device(
        '_Z31nvshmemx_int16_put_signal_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_int16_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmemx_int16_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int16_put_signal_block, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_int16_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_int16_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_int16_put_signal_block_nbst(shim_stream, shim_obj)


def int32_put_signal_block():
    pass
    

def _lower__Z31nvshmemx_int32_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_int32_put_signal_block_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int32_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_int32_put_signal_block_nbst = declare_device(
        '_Z31nvshmemx_int32_put_signal_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_int32_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmemx_int32_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int32_put_signal_block, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_int32_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_int32_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_int32_put_signal_block_nbst(shim_stream, shim_obj)


def int64_put_signal_block():
    pass
    

def _lower__Z31nvshmemx_int64_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_int64_put_signal_block_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int64_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_int64_put_signal_block_nbst = declare_device(
        '_Z31nvshmemx_int64_put_signal_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_int64_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmemx_int64_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int64_put_signal_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_int64_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_int64_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_int64_put_signal_block_nbst(shim_stream, shim_obj)


def uint8_put_signal_block():
    pass
    

def _lower__Z31nvshmemx_uint8_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_uint8_put_signal_block_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint8_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_uint8_put_signal_block_nbst = declare_device(
        '_Z31nvshmemx_uint8_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_uint8_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmemx_uint8_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint8_put_signal_block, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_uint8_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_uint8_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_uint8_put_signal_block_nbst(shim_stream, shim_obj)


def uint16_put_signal_block():
    pass
    

def _lower__Z32nvshmemx_uint16_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_uint16_put_signal_block_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint16_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z32nvshmemx_uint16_put_signal_block_nbst = declare_device(
        '_Z32nvshmemx_uint16_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_uint16_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z32nvshmemx_uint16_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint16_put_signal_block, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_uint16_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_uint16_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_uint16_put_signal_block_nbst(shim_stream, shim_obj)


def uint32_put_signal_block():
    pass
    

def _lower__Z32nvshmemx_uint32_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_uint32_put_signal_block_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint32_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z32nvshmemx_uint32_put_signal_block_nbst = declare_device(
        '_Z32nvshmemx_uint32_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_uint32_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z32nvshmemx_uint32_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint32_put_signal_block, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_uint32_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_uint32_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_uint32_put_signal_block_nbst(shim_stream, shim_obj)


def uint64_put_signal_block():
    pass
    

def _lower__Z32nvshmemx_uint64_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_uint64_put_signal_block_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint64_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z32nvshmemx_uint64_put_signal_block_nbst = declare_device(
        '_Z32nvshmemx_uint64_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_uint64_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z32nvshmemx_uint64_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint64_put_signal_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_uint64_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_uint64_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_uint64_put_signal_block_nbst(shim_stream, shim_obj)


def size_put_signal_block():
    pass
    

def _lower__Z30nvshmemx_size_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_size_put_signal_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_size_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_size_put_signal_block_nbst = declare_device(
        '_Z30nvshmemx_size_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_size_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmemx_size_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(size_put_signal_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_size_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_size_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_size_put_signal_block_nbst(shim_stream, shim_obj)


def ptrdiff_put_signal_block():
    pass
    

def _lower__Z33nvshmemx_ptrdiff_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_ptrdiff_put_signal_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_ptrdiff_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z33nvshmemx_ptrdiff_put_signal_block_nbst = declare_device(
        '_Z33nvshmemx_ptrdiff_put_signal_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_ptrdiff_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z33nvshmemx_ptrdiff_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ptrdiff_put_signal_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_ptrdiff_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_ptrdiff_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_ptrdiff_put_signal_block_nbst(shim_stream, shim_obj)


def putmem_signal_warp():
    pass
    

def _lower__Z27nvshmemx_putmem_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_putmem_signal_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_putmem_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_putmem_signal_warp_nbst = declare_device(
        '_Z27nvshmemx_putmem_signal_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_putmem_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z27nvshmemx_putmem_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(putmem_signal_warp, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_putmem_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_putmem_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_putmem_signal_warp_nbst(shim_stream, shim_obj)


def putmem_signal_block():
    pass
    

def _lower__Z28nvshmemx_putmem_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_putmem_signal_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_putmem_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_putmem_signal_block_nbst = declare_device(
        '_Z28nvshmemx_putmem_signal_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_putmem_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z28nvshmemx_putmem_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(putmem_signal_block, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_putmem_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_putmem_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_putmem_signal_block_nbst(shim_stream, shim_obj)


def put8_signal_warp():
    pass
    

def _lower__Z25nvshmemx_put8_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_put8_signal_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put8_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_put8_signal_warp_nbst = declare_device(
        '_Z25nvshmemx_put8_signal_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_put8_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z25nvshmemx_put8_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put8_signal_warp, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_put8_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_put8_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_put8_signal_warp_nbst(shim_stream, shim_obj)


def put6_signal_warp():
    pass
    

def _lower__Z25nvshmemx_put6_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_put6_signal_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put6_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_put6_signal_warp_nbst = declare_device(
        '_Z25nvshmemx_put6_signal_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_put6_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z25nvshmemx_put6_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put6_signal_warp, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_put6_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_put6_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_put6_signal_warp_nbst(shim_stream, shim_obj)


def put32_signal_warp():
    pass
    

def _lower__Z26nvshmemx_put32_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_put32_signal_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put32_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_put32_signal_warp_nbst = declare_device(
        '_Z26nvshmemx_put32_signal_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_put32_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z26nvshmemx_put32_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put32_signal_warp, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_put32_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_put32_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_put32_signal_warp_nbst(shim_stream, shim_obj)


def put64_signal_warp():
    pass
    

def _lower__Z26nvshmemx_put64_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_put64_signal_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put64_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_put64_signal_warp_nbst = declare_device(
        '_Z26nvshmemx_put64_signal_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_put64_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z26nvshmemx_put64_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put64_signal_warp, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_put64_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_put64_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_put64_signal_warp_nbst(shim_stream, shim_obj)


def put128_signal_warp():
    pass
    

def _lower__Z27nvshmemx_put128_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_put128_signal_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put128_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_put128_signal_warp_nbst = declare_device(
        '_Z27nvshmemx_put128_signal_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_put128_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z27nvshmemx_put128_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put128_signal_warp, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_put128_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_put128_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_put128_signal_warp_nbst(shim_stream, shim_obj)


def put8_signal_block():
    pass
    

def _lower__Z26nvshmemx_put8_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_put8_signal_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put8_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_put8_signal_block_nbst = declare_device(
        '_Z26nvshmemx_put8_signal_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_put8_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z26nvshmemx_put8_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put8_signal_block, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_put8_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_put8_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_put8_signal_block_nbst(shim_stream, shim_obj)


def put6_signal_block():
    pass
    

def _lower__Z26nvshmemx_put6_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_put6_signal_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put6_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_put6_signal_block_nbst = declare_device(
        '_Z26nvshmemx_put6_signal_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_put6_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z26nvshmemx_put6_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put6_signal_block, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_put6_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_put6_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_put6_signal_block_nbst(shim_stream, shim_obj)


def put32_signal_block():
    pass
    

def _lower__Z27nvshmemx_put32_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_put32_signal_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put32_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_put32_signal_block_nbst = declare_device(
        '_Z27nvshmemx_put32_signal_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_put32_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z27nvshmemx_put32_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put32_signal_block, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_put32_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_put32_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_put32_signal_block_nbst(shim_stream, shim_obj)


def put64_signal_block():
    pass
    

def _lower__Z27nvshmemx_put64_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_put64_signal_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put64_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_put64_signal_block_nbst = declare_device(
        '_Z27nvshmemx_put64_signal_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_put64_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z27nvshmemx_put64_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put64_signal_block, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_put64_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_put64_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_put64_signal_block_nbst(shim_stream, shim_obj)


def put128_signal_block():
    pass
    

def _lower__Z28nvshmemx_put128_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_put128_signal_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put128_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_put128_signal_block_nbst = declare_device(
        '_Z28nvshmemx_put128_signal_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_put128_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z28nvshmemx_put128_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put128_signal_block, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_put128_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_put128_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_put128_signal_block_nbst(shim_stream, shim_obj)


def bfloat16_put_signal_nbi_warp():
    pass
    

def _lower__Z37nvshmemx_bfloat16_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_bfloat16_put_signal_nbi_warp_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_bfloat16_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z37nvshmemx_bfloat16_put_signal_nbi_warp_nbst = declare_device(
        '_Z37nvshmemx_bfloat16_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_bfloat16_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z37nvshmemx_bfloat16_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(bfloat16_put_signal_nbi_warp, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_bfloat16_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_bfloat16_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_bfloat16_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def half_put_signal_nbi_warp():
    pass
    

def _lower__Z33nvshmemx_half_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_half_put_signal_nbi_warp_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_half_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z33nvshmemx_half_put_signal_nbi_warp_nbst = declare_device(
        '_Z33nvshmemx_half_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_half_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z33nvshmemx_half_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(half_put_signal_nbi_warp, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_half_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_half_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_half_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def float_put_signal_nbi_warp():
    pass
    

def _lower__Z34nvshmemx_float_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_float_put_signal_nbi_warp_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_float_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z34nvshmemx_float_put_signal_nbi_warp_nbst = declare_device(
        '_Z34nvshmemx_float_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_float_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z34nvshmemx_float_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(float_put_signal_nbi_warp, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_float_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_float_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_float_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def double_put_signal_nbi_warp():
    pass
    

def _lower__Z35nvshmemx_double_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_double_put_signal_nbi_warp_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_double_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z35nvshmemx_double_put_signal_nbi_warp_nbst = declare_device(
        '_Z35nvshmemx_double_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_double_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z35nvshmemx_double_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(double_put_signal_nbi_warp, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_double_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_double_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_double_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def char_put_signal_nbi_warp():
    pass
    

def _lower__Z33nvshmemx_char_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_char_put_signal_nbi_warp_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_char_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z33nvshmemx_char_put_signal_nbi_warp_nbst = declare_device(
        '_Z33nvshmemx_char_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_char_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z33nvshmemx_char_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(char_put_signal_nbi_warp, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_char_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_char_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_char_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def short_put_signal_nbi_warp():
    pass
    

def _lower__Z34nvshmemx_short_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_short_put_signal_nbi_warp_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_short_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z34nvshmemx_short_put_signal_nbi_warp_nbst = declare_device(
        '_Z34nvshmemx_short_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_short_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z34nvshmemx_short_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(short_put_signal_nbi_warp, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_short_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_short_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_short_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def schar_put_signal_nbi_warp():
    pass
    

def _lower__Z34nvshmemx_schar_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_schar_put_signal_nbi_warp_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_schar_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z34nvshmemx_schar_put_signal_nbi_warp_nbst = declare_device(
        '_Z34nvshmemx_schar_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_schar_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z34nvshmemx_schar_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(schar_put_signal_nbi_warp, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_schar_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_schar_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_schar_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def int_put_signal_nbi_warp():
    pass
    

def _lower__Z32nvshmemx_int_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_int_put_signal_nbi_warp_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z32nvshmemx_int_put_signal_nbi_warp_nbst = declare_device(
        '_Z32nvshmemx_int_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_int_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z32nvshmemx_int_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int_put_signal_nbi_warp, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_int_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_int_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_int_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def long_put_signal_nbi_warp():
    pass
    

def _lower__Z33nvshmemx_long_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_long_put_signal_nbi_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_long_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z33nvshmemx_long_put_signal_nbi_warp_nbst = declare_device(
        '_Z33nvshmemx_long_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_long_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z33nvshmemx_long_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(long_put_signal_nbi_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_long_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_long_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_long_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def longlong_put_signal_nbi_warp():
    pass
    

def _lower__Z37nvshmemx_longlong_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_longlong_put_signal_nbi_warp_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_longlong_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z37nvshmemx_longlong_put_signal_nbi_warp_nbst = declare_device(
        '_Z37nvshmemx_longlong_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_longlong_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z37nvshmemx_longlong_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(longlong_put_signal_nbi_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_longlong_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_longlong_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_longlong_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def uchar_put_signal_nbi_warp():
    pass
    

def _lower__Z34nvshmemx_uchar_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_uchar_put_signal_nbi_warp_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uchar_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z34nvshmemx_uchar_put_signal_nbi_warp_nbst = declare_device(
        '_Z34nvshmemx_uchar_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_uchar_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z34nvshmemx_uchar_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uchar_put_signal_nbi_warp, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_uchar_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_uchar_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_uchar_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def ushort_put_signal_nbi_warp():
    pass
    

def _lower__Z35nvshmemx_ushort_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_ushort_put_signal_nbi_warp_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_ushort_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z35nvshmemx_ushort_put_signal_nbi_warp_nbst = declare_device(
        '_Z35nvshmemx_ushort_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_ushort_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z35nvshmemx_ushort_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ushort_put_signal_nbi_warp, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_ushort_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_ushort_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_ushort_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def uint_put_signal_nbi_warp():
    pass
    

def _lower__Z33nvshmemx_uint_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_uint_put_signal_nbi_warp_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z33nvshmemx_uint_put_signal_nbi_warp_nbst = declare_device(
        '_Z33nvshmemx_uint_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_uint_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z33nvshmemx_uint_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint_put_signal_nbi_warp, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_uint_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_uint_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_uint_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def ulong_put_signal_nbi_warp():
    pass
    

def _lower__Z34nvshmemx_ulong_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_ulong_put_signal_nbi_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_ulong_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z34nvshmemx_ulong_put_signal_nbi_warp_nbst = declare_device(
        '_Z34nvshmemx_ulong_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_ulong_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z34nvshmemx_ulong_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ulong_put_signal_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_ulong_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_ulong_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_ulong_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def ulonglong_put_signal_nbi_warp():
    pass
    

def _lower__Z38nvshmemx_ulonglong_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmemx_ulonglong_put_signal_nbi_warp_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_ulonglong_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z38nvshmemx_ulonglong_put_signal_nbi_warp_nbst = declare_device(
        '_Z38nvshmemx_ulonglong_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z38nvshmemx_ulonglong_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z38nvshmemx_ulonglong_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ulonglong_put_signal_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z38nvshmemx_ulonglong_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmemx_ulonglong_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z38nvshmemx_ulonglong_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def int8_put_signal_nbi_warp():
    pass
    

def _lower__Z33nvshmemx_int8_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_int8_put_signal_nbi_warp_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int8_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z33nvshmemx_int8_put_signal_nbi_warp_nbst = declare_device(
        '_Z33nvshmemx_int8_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_int8_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z33nvshmemx_int8_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int8_put_signal_nbi_warp, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_int8_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_int8_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_int8_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def int16_put_signal_nbi_warp():
    pass
    

def _lower__Z34nvshmemx_int16_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_int16_put_signal_nbi_warp_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int16_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z34nvshmemx_int16_put_signal_nbi_warp_nbst = declare_device(
        '_Z34nvshmemx_int16_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_int16_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z34nvshmemx_int16_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int16_put_signal_nbi_warp, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_int16_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_int16_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_int16_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def int32_put_signal_nbi_warp():
    pass
    

def _lower__Z34nvshmemx_int32_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_int32_put_signal_nbi_warp_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int32_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z34nvshmemx_int32_put_signal_nbi_warp_nbst = declare_device(
        '_Z34nvshmemx_int32_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_int32_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z34nvshmemx_int32_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int32_put_signal_nbi_warp, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_int32_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_int32_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_int32_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def int64_put_signal_nbi_warp():
    pass
    

def _lower__Z34nvshmemx_int64_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_int64_put_signal_nbi_warp_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int64_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z34nvshmemx_int64_put_signal_nbi_warp_nbst = declare_device(
        '_Z34nvshmemx_int64_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_int64_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z34nvshmemx_int64_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int64_put_signal_nbi_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_int64_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_int64_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_int64_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def uint8_put_signal_nbi_warp():
    pass
    

def _lower__Z34nvshmemx_uint8_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_uint8_put_signal_nbi_warp_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint8_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z34nvshmemx_uint8_put_signal_nbi_warp_nbst = declare_device(
        '_Z34nvshmemx_uint8_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_uint8_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z34nvshmemx_uint8_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint8_put_signal_nbi_warp, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_uint8_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_uint8_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_uint8_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def uint16_put_signal_nbi_warp():
    pass
    

def _lower__Z35nvshmemx_uint16_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_uint16_put_signal_nbi_warp_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint16_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z35nvshmemx_uint16_put_signal_nbi_warp_nbst = declare_device(
        '_Z35nvshmemx_uint16_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_uint16_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z35nvshmemx_uint16_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint16_put_signal_nbi_warp, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_uint16_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_uint16_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_uint16_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def uint32_put_signal_nbi_warp():
    pass
    

def _lower__Z35nvshmemx_uint32_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_uint32_put_signal_nbi_warp_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint32_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z35nvshmemx_uint32_put_signal_nbi_warp_nbst = declare_device(
        '_Z35nvshmemx_uint32_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_uint32_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z35nvshmemx_uint32_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint32_put_signal_nbi_warp, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_uint32_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_uint32_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_uint32_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def uint64_put_signal_nbi_warp():
    pass
    

def _lower__Z35nvshmemx_uint64_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_uint64_put_signal_nbi_warp_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint64_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z35nvshmemx_uint64_put_signal_nbi_warp_nbst = declare_device(
        '_Z35nvshmemx_uint64_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_uint64_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z35nvshmemx_uint64_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint64_put_signal_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_uint64_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_uint64_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_uint64_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def size_put_signal_nbi_warp():
    pass
    

def _lower__Z33nvshmemx_size_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_size_put_signal_nbi_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_size_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z33nvshmemx_size_put_signal_nbi_warp_nbst = declare_device(
        '_Z33nvshmemx_size_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_size_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z33nvshmemx_size_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(size_put_signal_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_size_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_size_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_size_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def ptrdiff_put_signal_nbi_warp():
    pass
    

def _lower__Z36nvshmemx_ptrdiff_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmemx_ptrdiff_put_signal_nbi_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_ptrdiff_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z36nvshmemx_ptrdiff_put_signal_nbi_warp_nbst = declare_device(
        '_Z36nvshmemx_ptrdiff_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z36nvshmemx_ptrdiff_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z36nvshmemx_ptrdiff_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ptrdiff_put_signal_nbi_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z36nvshmemx_ptrdiff_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmemx_ptrdiff_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z36nvshmemx_ptrdiff_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def bfloat16_put_signal_nbi_block():
    pass
    

def _lower__Z38nvshmemx_bfloat16_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmemx_bfloat16_put_signal_nbi_block_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_bfloat16_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z38nvshmemx_bfloat16_put_signal_nbi_block_nbst = declare_device(
        '_Z38nvshmemx_bfloat16_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z38nvshmemx_bfloat16_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z38nvshmemx_bfloat16_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(bfloat16_put_signal_nbi_block, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z38nvshmemx_bfloat16_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmemx_bfloat16_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z38nvshmemx_bfloat16_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def half_put_signal_nbi_block():
    pass
    

def _lower__Z34nvshmemx_half_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_half_put_signal_nbi_block_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_half_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z34nvshmemx_half_put_signal_nbi_block_nbst = declare_device(
        '_Z34nvshmemx_half_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_half_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z34nvshmemx_half_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(half_put_signal_nbi_block, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_half_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_half_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_half_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def float_put_signal_nbi_block():
    pass
    

def _lower__Z35nvshmemx_float_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_float_put_signal_nbi_block_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_float_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z35nvshmemx_float_put_signal_nbi_block_nbst = declare_device(
        '_Z35nvshmemx_float_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_float_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z35nvshmemx_float_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(float_put_signal_nbi_block, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_float_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_float_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_float_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def double_put_signal_nbi_block():
    pass
    

def _lower__Z36nvshmemx_double_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmemx_double_put_signal_nbi_block_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_double_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z36nvshmemx_double_put_signal_nbi_block_nbst = declare_device(
        '_Z36nvshmemx_double_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z36nvshmemx_double_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z36nvshmemx_double_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(double_put_signal_nbi_block, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z36nvshmemx_double_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmemx_double_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z36nvshmemx_double_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def char_put_signal_nbi_block():
    pass
    

def _lower__Z34nvshmemx_char_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_char_put_signal_nbi_block_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_char_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z34nvshmemx_char_put_signal_nbi_block_nbst = declare_device(
        '_Z34nvshmemx_char_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_char_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z34nvshmemx_char_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(char_put_signal_nbi_block, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_char_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_char_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_char_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def short_put_signal_nbi_block():
    pass
    

def _lower__Z35nvshmemx_short_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_short_put_signal_nbi_block_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_short_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z35nvshmemx_short_put_signal_nbi_block_nbst = declare_device(
        '_Z35nvshmemx_short_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_short_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z35nvshmemx_short_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(short_put_signal_nbi_block, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_short_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_short_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_short_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def schar_put_signal_nbi_block():
    pass
    

def _lower__Z35nvshmemx_schar_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_schar_put_signal_nbi_block_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_schar_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z35nvshmemx_schar_put_signal_nbi_block_nbst = declare_device(
        '_Z35nvshmemx_schar_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_schar_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z35nvshmemx_schar_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(schar_put_signal_nbi_block, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_schar_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_schar_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_schar_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def int_put_signal_nbi_block():
    pass
    

def _lower__Z33nvshmemx_int_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_int_put_signal_nbi_block_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z33nvshmemx_int_put_signal_nbi_block_nbst = declare_device(
        '_Z33nvshmemx_int_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_int_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z33nvshmemx_int_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int_put_signal_nbi_block, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_int_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_int_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_int_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def long_put_signal_nbi_block():
    pass
    

def _lower__Z34nvshmemx_long_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_long_put_signal_nbi_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_long_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z34nvshmemx_long_put_signal_nbi_block_nbst = declare_device(
        '_Z34nvshmemx_long_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_long_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z34nvshmemx_long_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(long_put_signal_nbi_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_long_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_long_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_long_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def longlong_put_signal_nbi_block():
    pass
    

def _lower__Z38nvshmemx_longlong_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmemx_longlong_put_signal_nbi_block_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_longlong_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z38nvshmemx_longlong_put_signal_nbi_block_nbst = declare_device(
        '_Z38nvshmemx_longlong_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z38nvshmemx_longlong_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z38nvshmemx_longlong_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(longlong_put_signal_nbi_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z38nvshmemx_longlong_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmemx_longlong_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z38nvshmemx_longlong_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def uchar_put_signal_nbi_block():
    pass
    

def _lower__Z35nvshmemx_uchar_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_uchar_put_signal_nbi_block_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uchar_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z35nvshmemx_uchar_put_signal_nbi_block_nbst = declare_device(
        '_Z35nvshmemx_uchar_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_uchar_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z35nvshmemx_uchar_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uchar_put_signal_nbi_block, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_uchar_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_uchar_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_uchar_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def ushort_put_signal_nbi_block():
    pass
    

def _lower__Z36nvshmemx_ushort_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmemx_ushort_put_signal_nbi_block_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_ushort_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z36nvshmemx_ushort_put_signal_nbi_block_nbst = declare_device(
        '_Z36nvshmemx_ushort_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z36nvshmemx_ushort_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z36nvshmemx_ushort_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ushort_put_signal_nbi_block, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z36nvshmemx_ushort_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmemx_ushort_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z36nvshmemx_ushort_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def uint_put_signal_nbi_block():
    pass
    

def _lower__Z34nvshmemx_uint_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_uint_put_signal_nbi_block_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z34nvshmemx_uint_put_signal_nbi_block_nbst = declare_device(
        '_Z34nvshmemx_uint_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_uint_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z34nvshmemx_uint_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint_put_signal_nbi_block, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_uint_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_uint_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_uint_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def ulong_put_signal_nbi_block():
    pass
    

def _lower__Z35nvshmemx_ulong_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_ulong_put_signal_nbi_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_ulong_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z35nvshmemx_ulong_put_signal_nbi_block_nbst = declare_device(
        '_Z35nvshmemx_ulong_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_ulong_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z35nvshmemx_ulong_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ulong_put_signal_nbi_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_ulong_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_ulong_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_ulong_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def ulonglong_put_signal_nbi_block():
    pass
    

def _lower__Z39nvshmemx_ulonglong_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z39nvshmemx_ulonglong_put_signal_nbi_block_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_ulonglong_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z39nvshmemx_ulonglong_put_signal_nbi_block_nbst = declare_device(
        '_Z39nvshmemx_ulonglong_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z39nvshmemx_ulonglong_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z39nvshmemx_ulonglong_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ulonglong_put_signal_nbi_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z39nvshmemx_ulonglong_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z39nvshmemx_ulonglong_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z39nvshmemx_ulonglong_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def int8_put_signal_nbi_block():
    pass
    

def _lower__Z34nvshmemx_int8_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_int8_put_signal_nbi_block_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int8_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z34nvshmemx_int8_put_signal_nbi_block_nbst = declare_device(
        '_Z34nvshmemx_int8_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_int8_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z34nvshmemx_int8_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int8_put_signal_nbi_block, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_int8_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_int8_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_int8_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def int16_put_signal_nbi_block():
    pass
    

def _lower__Z35nvshmemx_int16_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_int16_put_signal_nbi_block_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int16_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z35nvshmemx_int16_put_signal_nbi_block_nbst = declare_device(
        '_Z35nvshmemx_int16_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_int16_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z35nvshmemx_int16_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int16_put_signal_nbi_block, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_int16_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_int16_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_int16_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def int32_put_signal_nbi_block():
    pass
    

def _lower__Z35nvshmemx_int32_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_int32_put_signal_nbi_block_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int32_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z35nvshmemx_int32_put_signal_nbi_block_nbst = declare_device(
        '_Z35nvshmemx_int32_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_int32_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z35nvshmemx_int32_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int32_put_signal_nbi_block, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_int32_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_int32_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_int32_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def int64_put_signal_nbi_block():
    pass
    

def _lower__Z35nvshmemx_int64_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_int64_put_signal_nbi_block_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_int64_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z35nvshmemx_int64_put_signal_nbi_block_nbst = declare_device(
        '_Z35nvshmemx_int64_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_int64_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z35nvshmemx_int64_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(int64_put_signal_nbi_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_int64_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_int64_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_int64_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def uint8_put_signal_nbi_block():
    pass
    

def _lower__Z35nvshmemx_uint8_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_uint8_put_signal_nbi_block_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint8_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z35nvshmemx_uint8_put_signal_nbi_block_nbst = declare_device(
        '_Z35nvshmemx_uint8_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_uint8_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z35nvshmemx_uint8_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint8_put_signal_nbi_block, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_uint8_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_uint8_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_uint8_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def uint16_put_signal_nbi_block():
    pass
    

def _lower__Z36nvshmemx_uint16_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmemx_uint16_put_signal_nbi_block_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint16_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z36nvshmemx_uint16_put_signal_nbi_block_nbst = declare_device(
        '_Z36nvshmemx_uint16_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z36nvshmemx_uint16_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z36nvshmemx_uint16_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint16_put_signal_nbi_block, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z36nvshmemx_uint16_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmemx_uint16_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z36nvshmemx_uint16_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def uint32_put_signal_nbi_block():
    pass
    

def _lower__Z36nvshmemx_uint32_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmemx_uint32_put_signal_nbi_block_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint32_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z36nvshmemx_uint32_put_signal_nbi_block_nbst = declare_device(
        '_Z36nvshmemx_uint32_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z36nvshmemx_uint32_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z36nvshmemx_uint32_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint32_put_signal_nbi_block, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z36nvshmemx_uint32_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmemx_uint32_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z36nvshmemx_uint32_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def uint64_put_signal_nbi_block():
    pass
    

def _lower__Z36nvshmemx_uint64_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmemx_uint64_put_signal_nbi_block_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_uint64_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z36nvshmemx_uint64_put_signal_nbi_block_nbst = declare_device(
        '_Z36nvshmemx_uint64_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z36nvshmemx_uint64_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z36nvshmemx_uint64_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(uint64_put_signal_nbi_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z36nvshmemx_uint64_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmemx_uint64_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z36nvshmemx_uint64_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def size_put_signal_nbi_block():
    pass
    

def _lower__Z34nvshmemx_size_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_size_put_signal_nbi_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_size_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z34nvshmemx_size_put_signal_nbi_block_nbst = declare_device(
        '_Z34nvshmemx_size_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_size_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z34nvshmemx_size_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(size_put_signal_nbi_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_size_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_size_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_size_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def ptrdiff_put_signal_nbi_block():
    pass
    

def _lower__Z37nvshmemx_ptrdiff_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_ptrdiff_put_signal_nbi_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_ptrdiff_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z37nvshmemx_ptrdiff_put_signal_nbi_block_nbst = declare_device(
        '_Z37nvshmemx_ptrdiff_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_ptrdiff_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z37nvshmemx_ptrdiff_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(ptrdiff_put_signal_nbi_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_ptrdiff_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_ptrdiff_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_ptrdiff_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def putmem_signal_nbi_warp():
    pass
    

def _lower__Z31nvshmemx_putmem_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_putmem_signal_nbi_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_putmem_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_putmem_signal_nbi_warp_nbst = declare_device(
        '_Z31nvshmemx_putmem_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_putmem_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmemx_putmem_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(putmem_signal_nbi_warp, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_putmem_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_putmem_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_putmem_signal_nbi_warp_nbst(shim_stream, shim_obj)


def putmem_signal_nbi_block():
    pass
    

def _lower__Z32nvshmemx_putmem_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_putmem_signal_nbi_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_putmem_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z32nvshmemx_putmem_signal_nbi_block_nbst = declare_device(
        '_Z32nvshmemx_putmem_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_putmem_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z32nvshmemx_putmem_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(putmem_signal_nbi_block, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_putmem_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_putmem_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_putmem_signal_nbi_block_nbst(shim_stream, shim_obj)


def put8_signal_nbi_warp():
    pass
    

def _lower__Z29nvshmemx_put8_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_put8_signal_nbi_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put8_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_put8_signal_nbi_warp_nbst = declare_device(
        '_Z29nvshmemx_put8_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_put8_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z29nvshmemx_put8_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put8_signal_nbi_warp, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_put8_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_put8_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_put8_signal_nbi_warp_nbst(shim_stream, shim_obj)


def put6_signal_nbi_warp():
    pass
    

def _lower__Z29nvshmemx_put6_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_put6_signal_nbi_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put6_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_put6_signal_nbi_warp_nbst = declare_device(
        '_Z29nvshmemx_put6_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_put6_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z29nvshmemx_put6_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put6_signal_nbi_warp, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_put6_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_put6_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_put6_signal_nbi_warp_nbst(shim_stream, shim_obj)


def put32_signal_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_put32_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_put32_signal_nbi_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put32_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_put32_signal_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_put32_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_put32_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmemx_put32_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put32_signal_nbi_warp, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_put32_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_put32_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_put32_signal_nbi_warp_nbst(shim_stream, shim_obj)


def put64_signal_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_put64_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_put64_signal_nbi_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put64_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_put64_signal_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_put64_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_put64_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmemx_put64_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put64_signal_nbi_warp, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_put64_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_put64_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_put64_signal_nbi_warp_nbst(shim_stream, shim_obj)


def put128_signal_nbi_warp():
    pass
    

def _lower__Z31nvshmemx_put128_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_put128_signal_nbi_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put128_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_put128_signal_nbi_warp_nbst = declare_device(
        '_Z31nvshmemx_put128_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_put128_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmemx_put128_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put128_signal_nbi_warp, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_put128_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_put128_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_put128_signal_nbi_warp_nbst(shim_stream, shim_obj)


def put8_signal_nbi_block():
    pass
    

def _lower__Z30nvshmemx_put8_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_put8_signal_nbi_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put8_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_put8_signal_nbi_block_nbst = declare_device(
        '_Z30nvshmemx_put8_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_put8_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmemx_put8_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put8_signal_nbi_block, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_put8_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_put8_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_put8_signal_nbi_block_nbst(shim_stream, shim_obj)


def put6_signal_nbi_block():
    pass
    

def _lower__Z30nvshmemx_put6_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_put6_signal_nbi_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put6_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_put6_signal_nbi_block_nbst = declare_device(
        '_Z30nvshmemx_put6_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_put6_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z30nvshmemx_put6_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put6_signal_nbi_block, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_put6_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_put6_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_put6_signal_nbi_block_nbst(shim_stream, shim_obj)


def put32_signal_nbi_block():
    pass
    

def _lower__Z31nvshmemx_put32_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_put32_signal_nbi_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put32_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_put32_signal_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_put32_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_put32_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmemx_put32_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put32_signal_nbi_block, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_put32_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_put32_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_put32_signal_nbi_block_nbst(shim_stream, shim_obj)


def put64_signal_nbi_block():
    pass
    

def _lower__Z31nvshmemx_put64_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_put64_signal_nbi_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put64_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_put64_signal_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_put64_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_put64_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z31nvshmemx_put64_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put64_signal_nbi_block, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_put64_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_put64_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_put64_signal_nbi_block_nbst(shim_stream, shim_obj)


def put128_signal_nbi_block():
    pass
    

def _lower__Z32nvshmemx_put128_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_put128_signal_nbi_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe) {
        nvshmemx_put128_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe);
        return 0;
    }
        """


    _Z32nvshmemx_put128_signal_nbi_block_nbst = declare_device(
        '_Z32nvshmemx_put128_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_put128_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6):
        return _Z32nvshmemx_put128_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6)
    

    @lower(put128_signal_nbi_block, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_put128_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_put128_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_put128_signal_nbi_block_nbst(shim_stream, shim_obj)


def bfloat16_get_warp():
    pass
    

def _lower__Z26nvshmemx_bfloat16_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_bfloat16_get_warp_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe) {
        nvshmemx_bfloat16_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_bfloat16_get_warp_nbst = declare_device(
        '_Z26nvshmemx_bfloat16_get_warp_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_bfloat16_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_bfloat16_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_get_warp, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_bfloat16_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_bfloat16_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_bfloat16_get_warp_nbst(shim_stream, shim_obj)


def bfloat16_get_block():
    pass
    

def _lower__Z27nvshmemx_bfloat16_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_bfloat16_get_block_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe) {
        nvshmemx_bfloat16_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_bfloat16_get_block_nbst = declare_device(
        '_Z27nvshmemx_bfloat16_get_block_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_bfloat16_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_bfloat16_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_get_block, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_bfloat16_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_bfloat16_get_block_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_bfloat16_get_block_nbst(shim_stream, shim_obj)


def half_get_warp():
    pass
    

def _lower__Z22nvshmemx_half_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_half_get_warp_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe) {
        nvshmemx_half_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_half_get_warp_nbst = declare_device(
        '_Z22nvshmemx_half_get_warp_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_half_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmemx_half_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_get_warp, CPointer(float16), CPointer(float16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_half_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_half_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_half_get_warp_nbst(shim_stream, shim_obj)


def half_get_block():
    pass
    

def _lower__Z23nvshmemx_half_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_half_get_block_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe) {
        nvshmemx_half_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_half_get_block_nbst = declare_device(
        '_Z23nvshmemx_half_get_block_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_half_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_half_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_get_block, CPointer(float16), CPointer(float16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_half_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_half_get_block_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_half_get_block_nbst(shim_stream, shim_obj)


def float_get_warp():
    pass
    

def _lower__Z23nvshmemx_float_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_float_get_warp_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe) {
        nvshmemx_float_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_float_get_warp_nbst = declare_device(
        '_Z23nvshmemx_float_get_warp_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_float_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_float_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_get_warp, CPointer(float32), CPointer(float32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_float_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_float_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_float_get_warp_nbst(shim_stream, shim_obj)


def float_get_block():
    pass
    

def _lower__Z24nvshmemx_float_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_float_get_block_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe) {
        nvshmemx_float_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_float_get_block_nbst = declare_device(
        '_Z24nvshmemx_float_get_block_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_float_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_float_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_get_block, CPointer(float32), CPointer(float32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_float_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_float_get_block_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_float_get_block_nbst(shim_stream, shim_obj)


def double_get_warp():
    pass
    

def _lower__Z24nvshmemx_double_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_double_get_warp_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe) {
        nvshmemx_double_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_double_get_warp_nbst = declare_device(
        '_Z24nvshmemx_double_get_warp_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_double_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_double_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_get_warp, CPointer(float64), CPointer(float64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_double_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_double_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_double_get_warp_nbst(shim_stream, shim_obj)


def double_get_block():
    pass
    

def _lower__Z25nvshmemx_double_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_double_get_block_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe) {
        nvshmemx_double_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_double_get_block_nbst = declare_device(
        '_Z25nvshmemx_double_get_block_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_double_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmemx_double_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_get_block, CPointer(float64), CPointer(float64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_double_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_double_get_block_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_double_get_block_nbst(shim_stream, shim_obj)


def char_get_warp():
    pass
    

def _lower__Z22nvshmemx_char_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_char_get_warp_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_char_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_char_get_warp_nbst = declare_device(
        '_Z22nvshmemx_char_get_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_char_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmemx_char_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_get_warp, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_char_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_char_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_char_get_warp_nbst(shim_stream, shim_obj)


def char_get_block():
    pass
    

def _lower__Z23nvshmemx_char_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_char_get_block_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_char_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_char_get_block_nbst = declare_device(
        '_Z23nvshmemx_char_get_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_char_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_char_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_get_block, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_char_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_char_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_char_get_block_nbst(shim_stream, shim_obj)


def short_get_warp():
    pass
    

def _lower__Z23nvshmemx_short_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_short_get_warp_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe) {
        nvshmemx_short_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_short_get_warp_nbst = declare_device(
        '_Z23nvshmemx_short_get_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_short_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_short_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_get_warp, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_short_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_short_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_short_get_warp_nbst(shim_stream, shim_obj)


def short_get_block():
    pass
    

def _lower__Z24nvshmemx_short_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_short_get_block_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe) {
        nvshmemx_short_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_short_get_block_nbst = declare_device(
        '_Z24nvshmemx_short_get_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_short_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_short_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_get_block, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_short_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_short_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_short_get_block_nbst(shim_stream, shim_obj)


def schar_get_warp():
    pass
    

def _lower__Z23nvshmemx_schar_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_schar_get_warp_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_schar_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_schar_get_warp_nbst = declare_device(
        '_Z23nvshmemx_schar_get_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_schar_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_schar_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_get_warp, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_schar_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_schar_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_schar_get_warp_nbst(shim_stream, shim_obj)


def schar_get_block():
    pass
    

def _lower__Z24nvshmemx_schar_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_schar_get_block_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_schar_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_schar_get_block_nbst = declare_device(
        '_Z24nvshmemx_schar_get_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_schar_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_schar_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_get_block, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_schar_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_schar_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_schar_get_block_nbst(shim_stream, shim_obj)


def int_get_warp():
    pass
    

def _lower__Z21nvshmemx_int_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_int_get_warp_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmemx_int_get_warp_nbst = declare_device(
        '_Z21nvshmemx_int_get_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_int_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmemx_int_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_get_warp, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_int_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_int_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_int_get_warp_nbst(shim_stream, shim_obj)


def int_get_block():
    pass
    

def _lower__Z22nvshmemx_int_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_int_get_block_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_int_get_block_nbst = declare_device(
        '_Z22nvshmemx_int_get_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_int_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmemx_int_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_get_block, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_int_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_int_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_int_get_block_nbst(shim_stream, shim_obj)


def long_get_warp():
    pass
    

def _lower__Z22nvshmemx_long_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_long_get_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_long_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_long_get_warp_nbst = declare_device(
        '_Z22nvshmemx_long_get_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_long_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmemx_long_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_get_warp, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_long_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_long_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_long_get_warp_nbst(shim_stream, shim_obj)


def long_get_block():
    pass
    

def _lower__Z23nvshmemx_long_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_long_get_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_long_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_long_get_block_nbst = declare_device(
        '_Z23nvshmemx_long_get_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_long_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_long_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_get_block, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_long_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_long_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_long_get_block_nbst(shim_stream, shim_obj)


def longlong_get_warp():
    pass
    

def _lower__Z26nvshmemx_longlong_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_longlong_get_warp_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_longlong_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_longlong_get_warp_nbst = declare_device(
        '_Z26nvshmemx_longlong_get_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_longlong_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_longlong_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_get_warp, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_longlong_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_longlong_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_longlong_get_warp_nbst(shim_stream, shim_obj)


def longlong_get_block():
    pass
    

def _lower__Z27nvshmemx_longlong_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_longlong_get_block_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_longlong_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_longlong_get_block_nbst = declare_device(
        '_Z27nvshmemx_longlong_get_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_longlong_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_longlong_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_get_block, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_longlong_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_longlong_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_longlong_get_block_nbst(shim_stream, shim_obj)


def uchar_get_warp():
    pass
    

def _lower__Z23nvshmemx_uchar_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_uchar_get_warp_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uchar_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_uchar_get_warp_nbst = declare_device(
        '_Z23nvshmemx_uchar_get_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_uchar_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_uchar_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_get_warp, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_uchar_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_uchar_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_uchar_get_warp_nbst(shim_stream, shim_obj)


def uchar_get_block():
    pass
    

def _lower__Z24nvshmemx_uchar_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_uchar_get_block_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uchar_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_uchar_get_block_nbst = declare_device(
        '_Z24nvshmemx_uchar_get_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_uchar_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_uchar_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_get_block, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_uchar_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_uchar_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_uchar_get_block_nbst(shim_stream, shim_obj)


def ushort_get_warp():
    pass
    

def _lower__Z24nvshmemx_ushort_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_ushort_get_warp_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ushort_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_ushort_get_warp_nbst = declare_device(
        '_Z24nvshmemx_ushort_get_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_ushort_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_ushort_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_get_warp, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_ushort_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_ushort_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_ushort_get_warp_nbst(shim_stream, shim_obj)


def ushort_get_block():
    pass
    

def _lower__Z25nvshmemx_ushort_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_ushort_get_block_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ushort_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_ushort_get_block_nbst = declare_device(
        '_Z25nvshmemx_ushort_get_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_ushort_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmemx_ushort_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_get_block, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_ushort_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_ushort_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_ushort_get_block_nbst(shim_stream, shim_obj)


def uint_get_warp():
    pass
    

def _lower__Z22nvshmemx_uint_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_uint_get_warp_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_uint_get_warp_nbst = declare_device(
        '_Z22nvshmemx_uint_get_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_uint_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmemx_uint_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_get_warp, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_uint_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_uint_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_uint_get_warp_nbst(shim_stream, shim_obj)


def uint_get_block():
    pass
    

def _lower__Z23nvshmemx_uint_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_uint_get_block_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_uint_get_block_nbst = declare_device(
        '_Z23nvshmemx_uint_get_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_uint_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_uint_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_get_block, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_uint_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_uint_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_uint_get_block_nbst(shim_stream, shim_obj)


def ulong_get_warp():
    pass
    

def _lower__Z23nvshmemx_ulong_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_ulong_get_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ulong_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_ulong_get_warp_nbst = declare_device(
        '_Z23nvshmemx_ulong_get_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_ulong_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_ulong_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_get_warp, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_ulong_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_ulong_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_ulong_get_warp_nbst(shim_stream, shim_obj)


def ulong_get_block():
    pass
    

def _lower__Z24nvshmemx_ulong_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_ulong_get_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ulong_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_ulong_get_block_nbst = declare_device(
        '_Z24nvshmemx_ulong_get_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_ulong_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_ulong_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_get_block, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_ulong_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_ulong_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_ulong_get_block_nbst(shim_stream, shim_obj)


def ulonglong_get_warp():
    pass
    

def _lower__Z27nvshmemx_ulonglong_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_ulonglong_get_warp_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ulonglong_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_ulonglong_get_warp_nbst = declare_device(
        '_Z27nvshmemx_ulonglong_get_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_ulonglong_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_ulonglong_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_get_warp, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_ulonglong_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_ulonglong_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_ulonglong_get_warp_nbst(shim_stream, shim_obj)


def ulonglong_get_block():
    pass
    

def _lower__Z28nvshmemx_ulonglong_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_ulonglong_get_block_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ulonglong_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_ulonglong_get_block_nbst = declare_device(
        '_Z28nvshmemx_ulonglong_get_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_ulonglong_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_ulonglong_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_get_block, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_ulonglong_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_ulonglong_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_ulonglong_get_block_nbst(shim_stream, shim_obj)


def int8_get_warp():
    pass
    

def _lower__Z22nvshmemx_int8_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_int8_get_warp_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int8_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_int8_get_warp_nbst = declare_device(
        '_Z22nvshmemx_int8_get_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_int8_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmemx_int8_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_get_warp, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_int8_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_int8_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_int8_get_warp_nbst(shim_stream, shim_obj)


def int8_get_block():
    pass
    

def _lower__Z23nvshmemx_int8_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_int8_get_block_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int8_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_int8_get_block_nbst = declare_device(
        '_Z23nvshmemx_int8_get_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_int8_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_int8_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_get_block, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_int8_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_int8_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_int8_get_block_nbst(shim_stream, shim_obj)


def int16_get_warp():
    pass
    

def _lower__Z23nvshmemx_int16_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_int16_get_warp_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int16_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_int16_get_warp_nbst = declare_device(
        '_Z23nvshmemx_int16_get_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_int16_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_int16_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_get_warp, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_int16_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_int16_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_int16_get_warp_nbst(shim_stream, shim_obj)


def int16_get_block():
    pass
    

def _lower__Z24nvshmemx_int16_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_int16_get_block_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int16_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_int16_get_block_nbst = declare_device(
        '_Z24nvshmemx_int16_get_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_int16_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_int16_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_get_block, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_int16_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_int16_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_int16_get_block_nbst(shim_stream, shim_obj)


def int32_get_warp():
    pass
    

def _lower__Z23nvshmemx_int32_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_int32_get_warp_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int32_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_int32_get_warp_nbst = declare_device(
        '_Z23nvshmemx_int32_get_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_int32_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_int32_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_get_warp, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_int32_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_int32_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_int32_get_warp_nbst(shim_stream, shim_obj)


def int32_get_block():
    pass
    

def _lower__Z24nvshmemx_int32_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_int32_get_block_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int32_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_int32_get_block_nbst = declare_device(
        '_Z24nvshmemx_int32_get_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_int32_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_int32_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_get_block, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_int32_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_int32_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_int32_get_block_nbst(shim_stream, shim_obj)


def int64_get_warp():
    pass
    

def _lower__Z23nvshmemx_int64_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_int64_get_warp_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int64_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_int64_get_warp_nbst = declare_device(
        '_Z23nvshmemx_int64_get_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_int64_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_int64_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_get_warp, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_int64_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_int64_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_int64_get_warp_nbst(shim_stream, shim_obj)


def int64_get_block():
    pass
    

def _lower__Z24nvshmemx_int64_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_int64_get_block_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int64_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_int64_get_block_nbst = declare_device(
        '_Z24nvshmemx_int64_get_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_int64_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_int64_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_get_block, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_int64_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_int64_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_int64_get_block_nbst(shim_stream, shim_obj)


def uint8_get_warp():
    pass
    

def _lower__Z23nvshmemx_uint8_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_uint8_get_warp_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint8_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_uint8_get_warp_nbst = declare_device(
        '_Z23nvshmemx_uint8_get_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_uint8_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_uint8_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_get_warp, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_uint8_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_uint8_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_uint8_get_warp_nbst(shim_stream, shim_obj)


def uint8_get_block():
    pass
    

def _lower__Z24nvshmemx_uint8_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_uint8_get_block_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint8_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_uint8_get_block_nbst = declare_device(
        '_Z24nvshmemx_uint8_get_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_uint8_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_uint8_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_get_block, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_uint8_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_uint8_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_uint8_get_block_nbst(shim_stream, shim_obj)


def uint16_get_warp():
    pass
    

def _lower__Z24nvshmemx_uint16_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_uint16_get_warp_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint16_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_uint16_get_warp_nbst = declare_device(
        '_Z24nvshmemx_uint16_get_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_uint16_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_uint16_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_get_warp, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_uint16_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_uint16_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_uint16_get_warp_nbst(shim_stream, shim_obj)


def uint16_get_block():
    pass
    

def _lower__Z25nvshmemx_uint16_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_uint16_get_block_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint16_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_uint16_get_block_nbst = declare_device(
        '_Z25nvshmemx_uint16_get_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_uint16_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmemx_uint16_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_get_block, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_uint16_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_uint16_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_uint16_get_block_nbst(shim_stream, shim_obj)


def uint32_get_warp():
    pass
    

def _lower__Z24nvshmemx_uint32_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_uint32_get_warp_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint32_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_uint32_get_warp_nbst = declare_device(
        '_Z24nvshmemx_uint32_get_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_uint32_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_uint32_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_get_warp, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_uint32_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_uint32_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_uint32_get_warp_nbst(shim_stream, shim_obj)


def uint32_get_block():
    pass
    

def _lower__Z25nvshmemx_uint32_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_uint32_get_block_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint32_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_uint32_get_block_nbst = declare_device(
        '_Z25nvshmemx_uint32_get_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_uint32_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmemx_uint32_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_get_block, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_uint32_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_uint32_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_uint32_get_block_nbst(shim_stream, shim_obj)


def uint64_get_warp():
    pass
    

def _lower__Z24nvshmemx_uint64_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_uint64_get_warp_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint64_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_uint64_get_warp_nbst = declare_device(
        '_Z24nvshmemx_uint64_get_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_uint64_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_uint64_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_get_warp, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_uint64_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_uint64_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_uint64_get_warp_nbst(shim_stream, shim_obj)


def uint64_get_block():
    pass
    

def _lower__Z25nvshmemx_uint64_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_uint64_get_block_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint64_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_uint64_get_block_nbst = declare_device(
        '_Z25nvshmemx_uint64_get_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_uint64_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmemx_uint64_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_get_block, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_uint64_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_uint64_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_uint64_get_block_nbst(shim_stream, shim_obj)


def size_get_warp():
    pass
    

def _lower__Z22nvshmemx_size_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_size_get_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_size_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_size_get_warp_nbst = declare_device(
        '_Z22nvshmemx_size_get_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_size_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmemx_size_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_get_warp, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_size_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_size_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_size_get_warp_nbst(shim_stream, shim_obj)


def size_get_block():
    pass
    

def _lower__Z23nvshmemx_size_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_size_get_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_size_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_size_get_block_nbst = declare_device(
        '_Z23nvshmemx_size_get_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_size_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_size_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_get_block, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_size_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_size_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_size_get_block_nbst(shim_stream, shim_obj)


def ptrdiff_get_warp():
    pass
    

def _lower__Z25nvshmemx_ptrdiff_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_ptrdiff_get_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ptrdiff_get_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_ptrdiff_get_warp_nbst = declare_device(
        '_Z25nvshmemx_ptrdiff_get_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_ptrdiff_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmemx_ptrdiff_get_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ptrdiff_get_warp, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_ptrdiff_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_ptrdiff_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_ptrdiff_get_warp_nbst(shim_stream, shim_obj)


def ptrdiff_get_block():
    pass
    

def _lower__Z26nvshmemx_ptrdiff_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_ptrdiff_get_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ptrdiff_get_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_ptrdiff_get_block_nbst = declare_device(
        '_Z26nvshmemx_ptrdiff_get_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_ptrdiff_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_ptrdiff_get_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ptrdiff_get_block, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_ptrdiff_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_ptrdiff_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_ptrdiff_get_block_nbst(shim_stream, shim_obj)


def put8_warp():
    pass
    

def _lower__Z18nvshmemx_put8_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmemx_put8_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put8_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmemx_put8_warp_nbst = declare_device(
        '_Z18nvshmemx_put8_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmemx_put8_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmemx_put8_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put8_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmemx_put8_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmemx_put8_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmemx_put8_warp_nbst(shim_stream, shim_obj)


def put8_block():
    pass
    

def _lower__Z19nvshmemx_put8_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_put8_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put8_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmemx_put8_block_nbst = declare_device(
        '_Z19nvshmemx_put8_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_put8_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmemx_put8_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put8_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_put8_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_put8_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_put8_block_nbst(shim_stream, shim_obj)


def put16_warp():
    pass
    

def _lower__Z19nvshmemx_put16_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_put16_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put16_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmemx_put16_warp_nbst = declare_device(
        '_Z19nvshmemx_put16_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_put16_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmemx_put16_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put16_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_put16_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_put16_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_put16_warp_nbst(shim_stream, shim_obj)


def put16_block():
    pass
    

def _lower__Z20nvshmemx_put16_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_put16_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put16_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmemx_put16_block_nbst = declare_device(
        '_Z20nvshmemx_put16_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_put16_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmemx_put16_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put16_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_put16_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_put16_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_put16_block_nbst(shim_stream, shim_obj)


def put32_warp():
    pass
    

def _lower__Z19nvshmemx_put32_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_put32_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put32_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmemx_put32_warp_nbst = declare_device(
        '_Z19nvshmemx_put32_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_put32_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmemx_put32_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put32_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_put32_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_put32_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_put32_warp_nbst(shim_stream, shim_obj)


def put32_block():
    pass
    

def _lower__Z20nvshmemx_put32_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_put32_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put32_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmemx_put32_block_nbst = declare_device(
        '_Z20nvshmemx_put32_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_put32_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmemx_put32_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put32_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_put32_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_put32_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_put32_block_nbst(shim_stream, shim_obj)


def put64_warp():
    pass
    

def _lower__Z19nvshmemx_put64_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_put64_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put64_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmemx_put64_warp_nbst = declare_device(
        '_Z19nvshmemx_put64_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_put64_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmemx_put64_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put64_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_put64_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_put64_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_put64_warp_nbst(shim_stream, shim_obj)


def put64_block():
    pass
    

def _lower__Z20nvshmemx_put64_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_put64_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put64_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmemx_put64_block_nbst = declare_device(
        '_Z20nvshmemx_put64_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_put64_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmemx_put64_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put64_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_put64_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_put64_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_put64_block_nbst(shim_stream, shim_obj)


def put128_warp():
    pass
    

def _lower__Z20nvshmemx_put128_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_put128_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put128_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmemx_put128_warp_nbst = declare_device(
        '_Z20nvshmemx_put128_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_put128_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmemx_put128_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put128_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_put128_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_put128_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_put128_warp_nbst(shim_stream, shim_obj)


def put128_block():
    pass
    

def _lower__Z21nvshmemx_put128_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_put128_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put128_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmemx_put128_block_nbst = declare_device(
        '_Z21nvshmemx_put128_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_put128_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmemx_put128_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put128_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_put128_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_put128_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_put128_block_nbst(shim_stream, shim_obj)


def get8_warp():
    pass
    

def _lower__Z18nvshmemx_get8_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmemx_get8_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get8_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z18nvshmemx_get8_warp_nbst = declare_device(
        '_Z18nvshmemx_get8_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z18nvshmemx_get8_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmemx_get8_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get8_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmemx_get8_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmemx_get8_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmemx_get8_warp_nbst(shim_stream, shim_obj)


def get8_block():
    pass
    

def _lower__Z19nvshmemx_get8_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_get8_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get8_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmemx_get8_block_nbst = declare_device(
        '_Z19nvshmemx_get8_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_get8_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmemx_get8_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get8_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_get8_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_get8_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_get8_block_nbst(shim_stream, shim_obj)


def get16_warp():
    pass
    

def _lower__Z19nvshmemx_get16_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_get16_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get16_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmemx_get16_warp_nbst = declare_device(
        '_Z19nvshmemx_get16_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_get16_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmemx_get16_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get16_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_get16_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_get16_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_get16_warp_nbst(shim_stream, shim_obj)


def get16_block():
    pass
    

def _lower__Z20nvshmemx_get16_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_get16_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get16_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmemx_get16_block_nbst = declare_device(
        '_Z20nvshmemx_get16_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_get16_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmemx_get16_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get16_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_get16_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_get16_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_get16_block_nbst(shim_stream, shim_obj)


def get32_warp():
    pass
    

def _lower__Z19nvshmemx_get32_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_get32_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get32_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmemx_get32_warp_nbst = declare_device(
        '_Z19nvshmemx_get32_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_get32_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmemx_get32_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get32_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_get32_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_get32_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_get32_warp_nbst(shim_stream, shim_obj)


def get32_block():
    pass
    

def _lower__Z20nvshmemx_get32_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_get32_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get32_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmemx_get32_block_nbst = declare_device(
        '_Z20nvshmemx_get32_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_get32_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmemx_get32_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get32_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_get32_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_get32_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_get32_block_nbst(shim_stream, shim_obj)


def get64_warp():
    pass
    

def _lower__Z19nvshmemx_get64_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_get64_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get64_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmemx_get64_warp_nbst = declare_device(
        '_Z19nvshmemx_get64_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_get64_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmemx_get64_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get64_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_get64_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_get64_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_get64_warp_nbst(shim_stream, shim_obj)


def get64_block():
    pass
    

def _lower__Z20nvshmemx_get64_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_get64_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get64_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmemx_get64_block_nbst = declare_device(
        '_Z20nvshmemx_get64_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_get64_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmemx_get64_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get64_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_get64_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_get64_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_get64_block_nbst(shim_stream, shim_obj)


def get128_warp():
    pass
    

def _lower__Z20nvshmemx_get128_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_get128_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get128_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmemx_get128_warp_nbst = declare_device(
        '_Z20nvshmemx_get128_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_get128_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmemx_get128_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get128_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_get128_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_get128_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_get128_warp_nbst(shim_stream, shim_obj)


def get128_block():
    pass
    

def _lower__Z21nvshmemx_get128_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_get128_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get128_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmemx_get128_block_nbst = declare_device(
        '_Z21nvshmemx_get128_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_get128_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmemx_get128_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get128_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_get128_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_get128_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_get128_block_nbst(shim_stream, shim_obj)


def putmem_warp():
    pass
    

def _lower__Z20nvshmemx_putmem_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_putmem_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* bytes, int* pe) {
        nvshmemx_putmem_warp(*dest, *source, *bytes, *pe);
        return 0;
    }
        """


    _Z20nvshmemx_putmem_warp_nbst = declare_device(
        '_Z20nvshmemx_putmem_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_putmem_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmemx_putmem_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(putmem_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_putmem_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_putmem_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_putmem_warp_nbst(shim_stream, shim_obj)


def putmem_block():
    pass
    

def _lower__Z21nvshmemx_putmem_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_putmem_block_nbst(int &retval , void ** dest, void ** source, unsigned long* bytes, int* pe) {
        nvshmemx_putmem_block(*dest, *source, *bytes, *pe);
        return 0;
    }
        """


    _Z21nvshmemx_putmem_block_nbst = declare_device(
        '_Z21nvshmemx_putmem_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_putmem_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmemx_putmem_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(putmem_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_putmem_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_putmem_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_putmem_block_nbst(shim_stream, shim_obj)


def getmem_warp():
    pass
    

def _lower__Z20nvshmemx_getmem_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_getmem_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* bytes, int* pe) {
        nvshmemx_getmem_warp(*dest, *source, *bytes, *pe);
        return 0;
    }
        """


    _Z20nvshmemx_getmem_warp_nbst = declare_device(
        '_Z20nvshmemx_getmem_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_getmem_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmemx_getmem_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(getmem_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_getmem_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_getmem_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_getmem_warp_nbst(shim_stream, shim_obj)


def getmem_block():
    pass
    

def _lower__Z21nvshmemx_getmem_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_getmem_block_nbst(int &retval , void ** dest, void ** source, unsigned long* bytes, int* pe) {
        nvshmemx_getmem_block(*dest, *source, *bytes, *pe);
        return 0;
    }
        """


    _Z21nvshmemx_getmem_block_nbst = declare_device(
        '_Z21nvshmemx_getmem_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_getmem_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmemx_getmem_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(getmem_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_getmem_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_getmem_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_getmem_block_nbst(shim_stream, shim_obj)


def bfloat16_put_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_bfloat16_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_bfloat16_put_nbi_warp_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe) {
        nvshmemx_bfloat16_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_bfloat16_put_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_bfloat16_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_bfloat16_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z30nvshmemx_bfloat16_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_put_nbi_warp, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_bfloat16_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_bfloat16_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_bfloat16_put_nbi_warp_nbst(shim_stream, shim_obj)


def bfloat16_put_nbi_block():
    pass
    

def _lower__Z31nvshmemx_bfloat16_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_bfloat16_put_nbi_block_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe) {
        nvshmemx_bfloat16_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_bfloat16_put_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_bfloat16_put_nbi_block_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_bfloat16_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z31nvshmemx_bfloat16_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_put_nbi_block, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_bfloat16_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_bfloat16_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_bfloat16_put_nbi_block_nbst(shim_stream, shim_obj)


def half_put_nbi_warp():
    pass
    

def _lower__Z26nvshmemx_half_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_half_put_nbi_warp_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe) {
        nvshmemx_half_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_half_put_nbi_warp_nbst = declare_device(
        '_Z26nvshmemx_half_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_half_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_half_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_put_nbi_warp, CPointer(float16), CPointer(float16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_half_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_half_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_half_put_nbi_warp_nbst(shim_stream, shim_obj)


def half_put_nbi_block():
    pass
    

def _lower__Z27nvshmemx_half_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_half_put_nbi_block_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe) {
        nvshmemx_half_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_half_put_nbi_block_nbst = declare_device(
        '_Z27nvshmemx_half_put_nbi_block_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_half_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_half_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_put_nbi_block, CPointer(float16), CPointer(float16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_half_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_half_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_half_put_nbi_block_nbst(shim_stream, shim_obj)


def float_put_nbi_warp():
    pass
    

def _lower__Z27nvshmemx_float_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_float_put_nbi_warp_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe) {
        nvshmemx_float_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_float_put_nbi_warp_nbst = declare_device(
        '_Z27nvshmemx_float_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_float_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_float_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_put_nbi_warp, CPointer(float32), CPointer(float32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_float_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_float_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_float_put_nbi_warp_nbst(shim_stream, shim_obj)


def float_put_nbi_block():
    pass
    

def _lower__Z28nvshmemx_float_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_float_put_nbi_block_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe) {
        nvshmemx_float_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_float_put_nbi_block_nbst = declare_device(
        '_Z28nvshmemx_float_put_nbi_block_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_float_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_float_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_put_nbi_block, CPointer(float32), CPointer(float32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_float_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_float_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_float_put_nbi_block_nbst(shim_stream, shim_obj)


def double_put_nbi_warp():
    pass
    

def _lower__Z28nvshmemx_double_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_double_put_nbi_warp_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe) {
        nvshmemx_double_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_double_put_nbi_warp_nbst = declare_device(
        '_Z28nvshmemx_double_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_double_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_double_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_put_nbi_warp, CPointer(float64), CPointer(float64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_double_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_double_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_double_put_nbi_warp_nbst(shim_stream, shim_obj)


def double_put_nbi_block():
    pass
    

def _lower__Z29nvshmemx_double_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_double_put_nbi_block_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe) {
        nvshmemx_double_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_double_put_nbi_block_nbst = declare_device(
        '_Z29nvshmemx_double_put_nbi_block_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_double_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z29nvshmemx_double_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_put_nbi_block, CPointer(float64), CPointer(float64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_double_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_double_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_double_put_nbi_block_nbst(shim_stream, shim_obj)


def char_put_nbi_warp():
    pass
    

def _lower__Z26nvshmemx_char_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_char_put_nbi_warp_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_char_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_char_put_nbi_warp_nbst = declare_device(
        '_Z26nvshmemx_char_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_char_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_char_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_put_nbi_warp, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_char_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_char_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_char_put_nbi_warp_nbst(shim_stream, shim_obj)


def char_put_nbi_block():
    pass
    

def _lower__Z27nvshmemx_char_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_char_put_nbi_block_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_char_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_char_put_nbi_block_nbst = declare_device(
        '_Z27nvshmemx_char_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_char_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_char_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_put_nbi_block, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_char_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_char_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_char_put_nbi_block_nbst(shim_stream, shim_obj)


def short_put_nbi_warp():
    pass
    

def _lower__Z27nvshmemx_short_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_short_put_nbi_warp_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe) {
        nvshmemx_short_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_short_put_nbi_warp_nbst = declare_device(
        '_Z27nvshmemx_short_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_short_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_short_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_put_nbi_warp, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_short_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_short_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_short_put_nbi_warp_nbst(shim_stream, shim_obj)


def short_put_nbi_block():
    pass
    

def _lower__Z28nvshmemx_short_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_short_put_nbi_block_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe) {
        nvshmemx_short_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_short_put_nbi_block_nbst = declare_device(
        '_Z28nvshmemx_short_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_short_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_short_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_put_nbi_block, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_short_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_short_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_short_put_nbi_block_nbst(shim_stream, shim_obj)


def schar_put_nbi_warp():
    pass
    

def _lower__Z27nvshmemx_schar_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_schar_put_nbi_warp_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_schar_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_schar_put_nbi_warp_nbst = declare_device(
        '_Z27nvshmemx_schar_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_schar_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_schar_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_put_nbi_warp, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_schar_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_schar_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_schar_put_nbi_warp_nbst(shim_stream, shim_obj)


def schar_put_nbi_block():
    pass
    

def _lower__Z28nvshmemx_schar_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_schar_put_nbi_block_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_schar_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_schar_put_nbi_block_nbst = declare_device(
        '_Z28nvshmemx_schar_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_schar_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_schar_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_put_nbi_block, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_schar_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_schar_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_schar_put_nbi_block_nbst(shim_stream, shim_obj)


def int_put_nbi_warp():
    pass
    

def _lower__Z25nvshmemx_int_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_int_put_nbi_warp_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_int_put_nbi_warp_nbst = declare_device(
        '_Z25nvshmemx_int_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_int_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmemx_int_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_put_nbi_warp, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_int_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_int_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_int_put_nbi_warp_nbst(shim_stream, shim_obj)


def int_put_nbi_block():
    pass
    

def _lower__Z26nvshmemx_int_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_int_put_nbi_block_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_int_put_nbi_block_nbst = declare_device(
        '_Z26nvshmemx_int_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_int_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_int_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_put_nbi_block, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_int_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_int_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_int_put_nbi_block_nbst(shim_stream, shim_obj)


def long_put_nbi_warp():
    pass
    

def _lower__Z26nvshmemx_long_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_long_put_nbi_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_long_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_long_put_nbi_warp_nbst = declare_device(
        '_Z26nvshmemx_long_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_long_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_long_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_put_nbi_warp, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_long_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_long_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_long_put_nbi_warp_nbst(shim_stream, shim_obj)


def long_put_nbi_block():
    pass
    

def _lower__Z27nvshmemx_long_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_long_put_nbi_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_long_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_long_put_nbi_block_nbst = declare_device(
        '_Z27nvshmemx_long_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_long_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_long_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_put_nbi_block, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_long_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_long_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_long_put_nbi_block_nbst(shim_stream, shim_obj)


def longlong_put_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_longlong_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_longlong_put_nbi_warp_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_longlong_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_longlong_put_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_longlong_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_longlong_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z30nvshmemx_longlong_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_put_nbi_warp, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_longlong_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_longlong_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_longlong_put_nbi_warp_nbst(shim_stream, shim_obj)


def longlong_put_nbi_block():
    pass
    

def _lower__Z31nvshmemx_longlong_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_longlong_put_nbi_block_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_longlong_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_longlong_put_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_longlong_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_longlong_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z31nvshmemx_longlong_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_put_nbi_block, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_longlong_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_longlong_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_longlong_put_nbi_block_nbst(shim_stream, shim_obj)


def uchar_put_nbi_warp():
    pass
    

def _lower__Z27nvshmemx_uchar_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_uchar_put_nbi_warp_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uchar_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_uchar_put_nbi_warp_nbst = declare_device(
        '_Z27nvshmemx_uchar_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_uchar_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_uchar_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_put_nbi_warp, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_uchar_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_uchar_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_uchar_put_nbi_warp_nbst(shim_stream, shim_obj)


def uchar_put_nbi_block():
    pass
    

def _lower__Z28nvshmemx_uchar_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_uchar_put_nbi_block_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uchar_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_uchar_put_nbi_block_nbst = declare_device(
        '_Z28nvshmemx_uchar_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_uchar_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_uchar_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_put_nbi_block, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_uchar_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_uchar_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_uchar_put_nbi_block_nbst(shim_stream, shim_obj)


def ushort_put_nbi_warp():
    pass
    

def _lower__Z28nvshmemx_ushort_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_ushort_put_nbi_warp_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ushort_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_ushort_put_nbi_warp_nbst = declare_device(
        '_Z28nvshmemx_ushort_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_ushort_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_ushort_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_put_nbi_warp, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_ushort_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_ushort_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_ushort_put_nbi_warp_nbst(shim_stream, shim_obj)


def ushort_put_nbi_block():
    pass
    

def _lower__Z29nvshmemx_ushort_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_ushort_put_nbi_block_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ushort_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_ushort_put_nbi_block_nbst = declare_device(
        '_Z29nvshmemx_ushort_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_ushort_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z29nvshmemx_ushort_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_put_nbi_block, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_ushort_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_ushort_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_ushort_put_nbi_block_nbst(shim_stream, shim_obj)


def uint_put_nbi_warp():
    pass
    

def _lower__Z26nvshmemx_uint_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_uint_put_nbi_warp_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_uint_put_nbi_warp_nbst = declare_device(
        '_Z26nvshmemx_uint_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_uint_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_uint_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_put_nbi_warp, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_uint_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_uint_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_uint_put_nbi_warp_nbst(shim_stream, shim_obj)


def uint_put_nbi_block():
    pass
    

def _lower__Z27nvshmemx_uint_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_uint_put_nbi_block_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_uint_put_nbi_block_nbst = declare_device(
        '_Z27nvshmemx_uint_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_uint_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_uint_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_put_nbi_block, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_uint_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_uint_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_uint_put_nbi_block_nbst(shim_stream, shim_obj)


def ulong_put_nbi_warp():
    pass
    

def _lower__Z27nvshmemx_ulong_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_ulong_put_nbi_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ulong_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_ulong_put_nbi_warp_nbst = declare_device(
        '_Z27nvshmemx_ulong_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_ulong_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_ulong_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_put_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_ulong_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_ulong_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_ulong_put_nbi_warp_nbst(shim_stream, shim_obj)


def ulong_put_nbi_block():
    pass
    

def _lower__Z28nvshmemx_ulong_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_ulong_put_nbi_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ulong_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_ulong_put_nbi_block_nbst = declare_device(
        '_Z28nvshmemx_ulong_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_ulong_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_ulong_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_put_nbi_block, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_ulong_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_ulong_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_ulong_put_nbi_block_nbst(shim_stream, shim_obj)


def ulonglong_put_nbi_warp():
    pass
    

def _lower__Z31nvshmemx_ulonglong_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_ulonglong_put_nbi_warp_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ulonglong_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_ulonglong_put_nbi_warp_nbst = declare_device(
        '_Z31nvshmemx_ulonglong_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_ulonglong_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z31nvshmemx_ulonglong_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_put_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_ulonglong_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_ulonglong_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_ulonglong_put_nbi_warp_nbst(shim_stream, shim_obj)


def ulonglong_put_nbi_block():
    pass
    

def _lower__Z32nvshmemx_ulonglong_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_ulonglong_put_nbi_block_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ulonglong_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z32nvshmemx_ulonglong_put_nbi_block_nbst = declare_device(
        '_Z32nvshmemx_ulonglong_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_ulonglong_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z32nvshmemx_ulonglong_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_put_nbi_block, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_ulonglong_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_ulonglong_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_ulonglong_put_nbi_block_nbst(shim_stream, shim_obj)


def int8_put_nbi_warp():
    pass
    

def _lower__Z26nvshmemx_int8_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_int8_put_nbi_warp_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int8_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_int8_put_nbi_warp_nbst = declare_device(
        '_Z26nvshmemx_int8_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_int8_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_int8_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_put_nbi_warp, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_int8_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_int8_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_int8_put_nbi_warp_nbst(shim_stream, shim_obj)


def int8_put_nbi_block():
    pass
    

def _lower__Z27nvshmemx_int8_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_int8_put_nbi_block_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int8_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_int8_put_nbi_block_nbst = declare_device(
        '_Z27nvshmemx_int8_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_int8_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_int8_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_put_nbi_block, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_int8_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_int8_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_int8_put_nbi_block_nbst(shim_stream, shim_obj)


def int16_put_nbi_warp():
    pass
    

def _lower__Z27nvshmemx_int16_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_int16_put_nbi_warp_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int16_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_int16_put_nbi_warp_nbst = declare_device(
        '_Z27nvshmemx_int16_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_int16_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_int16_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_put_nbi_warp, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_int16_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_int16_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_int16_put_nbi_warp_nbst(shim_stream, shim_obj)


def int16_put_nbi_block():
    pass
    

def _lower__Z28nvshmemx_int16_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_int16_put_nbi_block_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int16_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_int16_put_nbi_block_nbst = declare_device(
        '_Z28nvshmemx_int16_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_int16_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_int16_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_put_nbi_block, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_int16_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_int16_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_int16_put_nbi_block_nbst(shim_stream, shim_obj)


def int32_put_nbi_warp():
    pass
    

def _lower__Z27nvshmemx_int32_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_int32_put_nbi_warp_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int32_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_int32_put_nbi_warp_nbst = declare_device(
        '_Z27nvshmemx_int32_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_int32_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_int32_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_put_nbi_warp, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_int32_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_int32_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_int32_put_nbi_warp_nbst(shim_stream, shim_obj)


def int32_put_nbi_block():
    pass
    

def _lower__Z28nvshmemx_int32_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_int32_put_nbi_block_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int32_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_int32_put_nbi_block_nbst = declare_device(
        '_Z28nvshmemx_int32_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_int32_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_int32_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_put_nbi_block, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_int32_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_int32_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_int32_put_nbi_block_nbst(shim_stream, shim_obj)


def int64_put_nbi_warp():
    pass
    

def _lower__Z27nvshmemx_int64_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_int64_put_nbi_warp_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int64_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_int64_put_nbi_warp_nbst = declare_device(
        '_Z27nvshmemx_int64_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_int64_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_int64_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_put_nbi_warp, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_int64_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_int64_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_int64_put_nbi_warp_nbst(shim_stream, shim_obj)


def int64_put_nbi_block():
    pass
    

def _lower__Z28nvshmemx_int64_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_int64_put_nbi_block_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int64_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_int64_put_nbi_block_nbst = declare_device(
        '_Z28nvshmemx_int64_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_int64_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_int64_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_put_nbi_block, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_int64_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_int64_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_int64_put_nbi_block_nbst(shim_stream, shim_obj)


def uint8_put_nbi_warp():
    pass
    

def _lower__Z27nvshmemx_uint8_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_uint8_put_nbi_warp_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint8_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_uint8_put_nbi_warp_nbst = declare_device(
        '_Z27nvshmemx_uint8_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_uint8_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_uint8_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_put_nbi_warp, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_uint8_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_uint8_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_uint8_put_nbi_warp_nbst(shim_stream, shim_obj)


def uint8_put_nbi_block():
    pass
    

def _lower__Z28nvshmemx_uint8_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_uint8_put_nbi_block_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint8_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_uint8_put_nbi_block_nbst = declare_device(
        '_Z28nvshmemx_uint8_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_uint8_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_uint8_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_put_nbi_block, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_uint8_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_uint8_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_uint8_put_nbi_block_nbst(shim_stream, shim_obj)


def uint16_put_nbi_warp():
    pass
    

def _lower__Z28nvshmemx_uint16_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_uint16_put_nbi_warp_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint16_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_uint16_put_nbi_warp_nbst = declare_device(
        '_Z28nvshmemx_uint16_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_uint16_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_uint16_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_put_nbi_warp, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_uint16_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_uint16_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_uint16_put_nbi_warp_nbst(shim_stream, shim_obj)


def uint16_put_nbi_block():
    pass
    

def _lower__Z29nvshmemx_uint16_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_uint16_put_nbi_block_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint16_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_uint16_put_nbi_block_nbst = declare_device(
        '_Z29nvshmemx_uint16_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_uint16_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z29nvshmemx_uint16_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_put_nbi_block, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_uint16_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_uint16_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_uint16_put_nbi_block_nbst(shim_stream, shim_obj)


def uint32_put_nbi_warp():
    pass
    

def _lower__Z28nvshmemx_uint32_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_uint32_put_nbi_warp_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint32_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_uint32_put_nbi_warp_nbst = declare_device(
        '_Z28nvshmemx_uint32_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_uint32_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_uint32_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_put_nbi_warp, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_uint32_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_uint32_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_uint32_put_nbi_warp_nbst(shim_stream, shim_obj)


def uint32_put_nbi_block():
    pass
    

def _lower__Z29nvshmemx_uint32_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_uint32_put_nbi_block_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint32_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_uint32_put_nbi_block_nbst = declare_device(
        '_Z29nvshmemx_uint32_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_uint32_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z29nvshmemx_uint32_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_put_nbi_block, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_uint32_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_uint32_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_uint32_put_nbi_block_nbst(shim_stream, shim_obj)


def uint64_put_nbi_warp():
    pass
    

def _lower__Z28nvshmemx_uint64_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_uint64_put_nbi_warp_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint64_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_uint64_put_nbi_warp_nbst = declare_device(
        '_Z28nvshmemx_uint64_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_uint64_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_uint64_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_put_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_uint64_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_uint64_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_uint64_put_nbi_warp_nbst(shim_stream, shim_obj)


def uint64_put_nbi_block():
    pass
    

def _lower__Z29nvshmemx_uint64_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_uint64_put_nbi_block_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint64_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_uint64_put_nbi_block_nbst = declare_device(
        '_Z29nvshmemx_uint64_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_uint64_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z29nvshmemx_uint64_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_put_nbi_block, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_uint64_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_uint64_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_uint64_put_nbi_block_nbst(shim_stream, shim_obj)


def size_put_nbi_warp():
    pass
    

def _lower__Z26nvshmemx_size_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_size_put_nbi_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_size_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_size_put_nbi_warp_nbst = declare_device(
        '_Z26nvshmemx_size_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_size_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_size_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_put_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_size_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_size_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_size_put_nbi_warp_nbst(shim_stream, shim_obj)


def size_put_nbi_block():
    pass
    

def _lower__Z27nvshmemx_size_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_size_put_nbi_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_size_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_size_put_nbi_block_nbst = declare_device(
        '_Z27nvshmemx_size_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_size_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_size_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_put_nbi_block, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_size_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_size_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_size_put_nbi_block_nbst(shim_stream, shim_obj)


def ptrdiff_put_nbi_warp():
    pass
    

def _lower__Z29nvshmemx_ptrdiff_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_ptrdiff_put_nbi_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ptrdiff_put_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_ptrdiff_put_nbi_warp_nbst = declare_device(
        '_Z29nvshmemx_ptrdiff_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_ptrdiff_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z29nvshmemx_ptrdiff_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ptrdiff_put_nbi_warp, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_ptrdiff_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_ptrdiff_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_ptrdiff_put_nbi_warp_nbst(shim_stream, shim_obj)


def ptrdiff_put_nbi_block():
    pass
    

def _lower__Z30nvshmemx_ptrdiff_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_ptrdiff_put_nbi_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ptrdiff_put_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_ptrdiff_put_nbi_block_nbst = declare_device(
        '_Z30nvshmemx_ptrdiff_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_ptrdiff_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z30nvshmemx_ptrdiff_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ptrdiff_put_nbi_block, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_ptrdiff_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_ptrdiff_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_ptrdiff_put_nbi_block_nbst(shim_stream, shim_obj)


def bfloat16_get_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_bfloat16_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_bfloat16_get_nbi_warp_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe) {
        nvshmemx_bfloat16_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_bfloat16_get_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_bfloat16_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_bfloat16_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z30nvshmemx_bfloat16_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_get_nbi_warp, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_bfloat16_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_bfloat16_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_bfloat16_get_nbi_warp_nbst(shim_stream, shim_obj)


def bfloat16_get_nbi_block():
    pass
    

def _lower__Z31nvshmemx_bfloat16_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_bfloat16_get_nbi_block_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe) {
        nvshmemx_bfloat16_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_bfloat16_get_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_bfloat16_get_nbi_block_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_bfloat16_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z31nvshmemx_bfloat16_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_get_nbi_block, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_bfloat16_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_bfloat16_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_bfloat16_get_nbi_block_nbst(shim_stream, shim_obj)


def half_get_nbi_warp():
    pass
    

def _lower__Z26nvshmemx_half_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_half_get_nbi_warp_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe) {
        nvshmemx_half_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_half_get_nbi_warp_nbst = declare_device(
        '_Z26nvshmemx_half_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_half_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_half_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_get_nbi_warp, CPointer(float16), CPointer(float16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_half_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_half_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_half_get_nbi_warp_nbst(shim_stream, shim_obj)


def half_get_nbi_block():
    pass
    

def _lower__Z27nvshmemx_half_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_half_get_nbi_block_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe) {
        nvshmemx_half_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_half_get_nbi_block_nbst = declare_device(
        '_Z27nvshmemx_half_get_nbi_block_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_half_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_half_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_get_nbi_block, CPointer(float16), CPointer(float16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_half_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_half_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_half_get_nbi_block_nbst(shim_stream, shim_obj)


def float_get_nbi_warp():
    pass
    

def _lower__Z27nvshmemx_float_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_float_get_nbi_warp_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe) {
        nvshmemx_float_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_float_get_nbi_warp_nbst = declare_device(
        '_Z27nvshmemx_float_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_float_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_float_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_get_nbi_warp, CPointer(float32), CPointer(float32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_float_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_float_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_float_get_nbi_warp_nbst(shim_stream, shim_obj)


def float_get_nbi_block():
    pass
    

def _lower__Z28nvshmemx_float_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_float_get_nbi_block_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe) {
        nvshmemx_float_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_float_get_nbi_block_nbst = declare_device(
        '_Z28nvshmemx_float_get_nbi_block_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_float_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_float_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_get_nbi_block, CPointer(float32), CPointer(float32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_float_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_float_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_float_get_nbi_block_nbst(shim_stream, shim_obj)


def double_get_nbi_warp():
    pass
    

def _lower__Z28nvshmemx_double_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_double_get_nbi_warp_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe) {
        nvshmemx_double_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_double_get_nbi_warp_nbst = declare_device(
        '_Z28nvshmemx_double_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_double_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_double_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_get_nbi_warp, CPointer(float64), CPointer(float64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_double_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_double_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_double_get_nbi_warp_nbst(shim_stream, shim_obj)


def double_get_nbi_block():
    pass
    

def _lower__Z29nvshmemx_double_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_double_get_nbi_block_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe) {
        nvshmemx_double_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_double_get_nbi_block_nbst = declare_device(
        '_Z29nvshmemx_double_get_nbi_block_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_double_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z29nvshmemx_double_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_get_nbi_block, CPointer(float64), CPointer(float64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_double_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_double_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_double_get_nbi_block_nbst(shim_stream, shim_obj)


def char_get_nbi_warp():
    pass
    

def _lower__Z26nvshmemx_char_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_char_get_nbi_warp_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_char_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_char_get_nbi_warp_nbst = declare_device(
        '_Z26nvshmemx_char_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_char_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_char_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_get_nbi_warp, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_char_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_char_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_char_get_nbi_warp_nbst(shim_stream, shim_obj)


def char_get_nbi_block():
    pass
    

def _lower__Z27nvshmemx_char_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_char_get_nbi_block_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_char_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_char_get_nbi_block_nbst = declare_device(
        '_Z27nvshmemx_char_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_char_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_char_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_get_nbi_block, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_char_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_char_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_char_get_nbi_block_nbst(shim_stream, shim_obj)


def short_get_nbi_warp():
    pass
    

def _lower__Z27nvshmemx_short_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_short_get_nbi_warp_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe) {
        nvshmemx_short_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_short_get_nbi_warp_nbst = declare_device(
        '_Z27nvshmemx_short_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_short_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_short_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_get_nbi_warp, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_short_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_short_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_short_get_nbi_warp_nbst(shim_stream, shim_obj)


def short_get_nbi_block():
    pass
    

def _lower__Z28nvshmemx_short_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_short_get_nbi_block_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe) {
        nvshmemx_short_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_short_get_nbi_block_nbst = declare_device(
        '_Z28nvshmemx_short_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_short_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_short_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_get_nbi_block, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_short_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_short_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_short_get_nbi_block_nbst(shim_stream, shim_obj)


def schar_get_nbi_warp():
    pass
    

def _lower__Z27nvshmemx_schar_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_schar_get_nbi_warp_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_schar_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_schar_get_nbi_warp_nbst = declare_device(
        '_Z27nvshmemx_schar_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_schar_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_schar_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_get_nbi_warp, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_schar_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_schar_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_schar_get_nbi_warp_nbst(shim_stream, shim_obj)


def schar_get_nbi_block():
    pass
    

def _lower__Z28nvshmemx_schar_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_schar_get_nbi_block_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_schar_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_schar_get_nbi_block_nbst = declare_device(
        '_Z28nvshmemx_schar_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_schar_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_schar_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_get_nbi_block, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_schar_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_schar_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_schar_get_nbi_block_nbst(shim_stream, shim_obj)


def int_get_nbi_warp():
    pass
    

def _lower__Z25nvshmemx_int_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_int_get_nbi_warp_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_int_get_nbi_warp_nbst = declare_device(
        '_Z25nvshmemx_int_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_int_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmemx_int_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_get_nbi_warp, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_int_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_int_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_int_get_nbi_warp_nbst(shim_stream, shim_obj)


def int_get_nbi_block():
    pass
    

def _lower__Z26nvshmemx_int_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_int_get_nbi_block_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_int_get_nbi_block_nbst = declare_device(
        '_Z26nvshmemx_int_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_int_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_int_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_get_nbi_block, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_int_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_int_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_int_get_nbi_block_nbst(shim_stream, shim_obj)


def long_get_nbi_warp():
    pass
    

def _lower__Z26nvshmemx_long_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_long_get_nbi_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_long_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_long_get_nbi_warp_nbst = declare_device(
        '_Z26nvshmemx_long_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_long_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_long_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_get_nbi_warp, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_long_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_long_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_long_get_nbi_warp_nbst(shim_stream, shim_obj)


def long_get_nbi_block():
    pass
    

def _lower__Z27nvshmemx_long_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_long_get_nbi_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_long_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_long_get_nbi_block_nbst = declare_device(
        '_Z27nvshmemx_long_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_long_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_long_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_get_nbi_block, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_long_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_long_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_long_get_nbi_block_nbst(shim_stream, shim_obj)


def longlong_get_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_longlong_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_longlong_get_nbi_warp_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_longlong_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_longlong_get_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_longlong_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_longlong_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z30nvshmemx_longlong_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_get_nbi_warp, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_longlong_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_longlong_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_longlong_get_nbi_warp_nbst(shim_stream, shim_obj)


def longlong_get_nbi_block():
    pass
    

def _lower__Z31nvshmemx_longlong_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_longlong_get_nbi_block_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_longlong_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_longlong_get_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_longlong_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_longlong_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z31nvshmemx_longlong_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_get_nbi_block, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_longlong_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_longlong_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_longlong_get_nbi_block_nbst(shim_stream, shim_obj)


def uchar_get_nbi_warp():
    pass
    

def _lower__Z27nvshmemx_uchar_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_uchar_get_nbi_warp_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uchar_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_uchar_get_nbi_warp_nbst = declare_device(
        '_Z27nvshmemx_uchar_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_uchar_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_uchar_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_get_nbi_warp, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_uchar_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_uchar_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_uchar_get_nbi_warp_nbst(shim_stream, shim_obj)


def uchar_get_nbi_block():
    pass
    

def _lower__Z28nvshmemx_uchar_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_uchar_get_nbi_block_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uchar_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_uchar_get_nbi_block_nbst = declare_device(
        '_Z28nvshmemx_uchar_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_uchar_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_uchar_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_get_nbi_block, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_uchar_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_uchar_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_uchar_get_nbi_block_nbst(shim_stream, shim_obj)


def ushort_get_nbi_warp():
    pass
    

def _lower__Z28nvshmemx_ushort_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_ushort_get_nbi_warp_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ushort_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_ushort_get_nbi_warp_nbst = declare_device(
        '_Z28nvshmemx_ushort_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_ushort_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_ushort_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_get_nbi_warp, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_ushort_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_ushort_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_ushort_get_nbi_warp_nbst(shim_stream, shim_obj)


def ushort_get_nbi_block():
    pass
    

def _lower__Z29nvshmemx_ushort_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_ushort_get_nbi_block_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ushort_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_ushort_get_nbi_block_nbst = declare_device(
        '_Z29nvshmemx_ushort_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_ushort_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z29nvshmemx_ushort_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_get_nbi_block, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_ushort_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_ushort_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_ushort_get_nbi_block_nbst(shim_stream, shim_obj)


def uint_get_nbi_warp():
    pass
    

def _lower__Z26nvshmemx_uint_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_uint_get_nbi_warp_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_uint_get_nbi_warp_nbst = declare_device(
        '_Z26nvshmemx_uint_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_uint_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_uint_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_get_nbi_warp, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_uint_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_uint_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_uint_get_nbi_warp_nbst(shim_stream, shim_obj)


def uint_get_nbi_block():
    pass
    

def _lower__Z27nvshmemx_uint_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_uint_get_nbi_block_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_uint_get_nbi_block_nbst = declare_device(
        '_Z27nvshmemx_uint_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_uint_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_uint_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_get_nbi_block, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_uint_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_uint_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_uint_get_nbi_block_nbst(shim_stream, shim_obj)


def ulong_get_nbi_warp():
    pass
    

def _lower__Z27nvshmemx_ulong_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_ulong_get_nbi_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ulong_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_ulong_get_nbi_warp_nbst = declare_device(
        '_Z27nvshmemx_ulong_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_ulong_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_ulong_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_get_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_ulong_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_ulong_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_ulong_get_nbi_warp_nbst(shim_stream, shim_obj)


def ulong_get_nbi_block():
    pass
    

def _lower__Z28nvshmemx_ulong_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_ulong_get_nbi_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ulong_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_ulong_get_nbi_block_nbst = declare_device(
        '_Z28nvshmemx_ulong_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_ulong_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_ulong_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_get_nbi_block, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_ulong_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_ulong_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_ulong_get_nbi_block_nbst(shim_stream, shim_obj)


def ulonglong_get_nbi_warp():
    pass
    

def _lower__Z31nvshmemx_ulonglong_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_ulonglong_get_nbi_warp_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ulonglong_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z31nvshmemx_ulonglong_get_nbi_warp_nbst = declare_device(
        '_Z31nvshmemx_ulonglong_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_ulonglong_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z31nvshmemx_ulonglong_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_get_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_ulonglong_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_ulonglong_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_ulonglong_get_nbi_warp_nbst(shim_stream, shim_obj)


def ulonglong_get_nbi_block():
    pass
    

def _lower__Z32nvshmemx_ulonglong_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_ulonglong_get_nbi_block_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ulonglong_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z32nvshmemx_ulonglong_get_nbi_block_nbst = declare_device(
        '_Z32nvshmemx_ulonglong_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_ulonglong_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z32nvshmemx_ulonglong_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_get_nbi_block, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_ulonglong_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_ulonglong_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_ulonglong_get_nbi_block_nbst(shim_stream, shim_obj)


def int8_get_nbi_warp():
    pass
    

def _lower__Z26nvshmemx_int8_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_int8_get_nbi_warp_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int8_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_int8_get_nbi_warp_nbst = declare_device(
        '_Z26nvshmemx_int8_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_int8_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_int8_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_get_nbi_warp, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_int8_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_int8_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_int8_get_nbi_warp_nbst(shim_stream, shim_obj)


def int8_get_nbi_block():
    pass
    

def _lower__Z27nvshmemx_int8_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_int8_get_nbi_block_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int8_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_int8_get_nbi_block_nbst = declare_device(
        '_Z27nvshmemx_int8_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_int8_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_int8_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_get_nbi_block, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_int8_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_int8_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_int8_get_nbi_block_nbst(shim_stream, shim_obj)


def int16_get_nbi_warp():
    pass
    

def _lower__Z27nvshmemx_int16_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_int16_get_nbi_warp_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int16_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_int16_get_nbi_warp_nbst = declare_device(
        '_Z27nvshmemx_int16_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_int16_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_int16_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_get_nbi_warp, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_int16_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_int16_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_int16_get_nbi_warp_nbst(shim_stream, shim_obj)


def int16_get_nbi_block():
    pass
    

def _lower__Z28nvshmemx_int16_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_int16_get_nbi_block_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int16_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_int16_get_nbi_block_nbst = declare_device(
        '_Z28nvshmemx_int16_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_int16_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_int16_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_get_nbi_block, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_int16_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_int16_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_int16_get_nbi_block_nbst(shim_stream, shim_obj)


def int32_get_nbi_warp():
    pass
    

def _lower__Z27nvshmemx_int32_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_int32_get_nbi_warp_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int32_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_int32_get_nbi_warp_nbst = declare_device(
        '_Z27nvshmemx_int32_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_int32_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_int32_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_get_nbi_warp, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_int32_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_int32_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_int32_get_nbi_warp_nbst(shim_stream, shim_obj)


def int32_get_nbi_block():
    pass
    

def _lower__Z28nvshmemx_int32_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_int32_get_nbi_block_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int32_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_int32_get_nbi_block_nbst = declare_device(
        '_Z28nvshmemx_int32_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_int32_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_int32_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_get_nbi_block, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_int32_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_int32_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_int32_get_nbi_block_nbst(shim_stream, shim_obj)


def int64_get_nbi_warp():
    pass
    

def _lower__Z27nvshmemx_int64_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_int64_get_nbi_warp_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int64_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_int64_get_nbi_warp_nbst = declare_device(
        '_Z27nvshmemx_int64_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_int64_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_int64_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_get_nbi_warp, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_int64_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_int64_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_int64_get_nbi_warp_nbst(shim_stream, shim_obj)


def int64_get_nbi_block():
    pass
    

def _lower__Z28nvshmemx_int64_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_int64_get_nbi_block_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_int64_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_int64_get_nbi_block_nbst = declare_device(
        '_Z28nvshmemx_int64_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_int64_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_int64_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_get_nbi_block, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_int64_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_int64_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_int64_get_nbi_block_nbst(shim_stream, shim_obj)


def uint8_get_nbi_warp():
    pass
    

def _lower__Z27nvshmemx_uint8_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_uint8_get_nbi_warp_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint8_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_uint8_get_nbi_warp_nbst = declare_device(
        '_Z27nvshmemx_uint8_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_uint8_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_uint8_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_get_nbi_warp, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_uint8_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_uint8_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_uint8_get_nbi_warp_nbst(shim_stream, shim_obj)


def uint8_get_nbi_block():
    pass
    

def _lower__Z28nvshmemx_uint8_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_uint8_get_nbi_block_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint8_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_uint8_get_nbi_block_nbst = declare_device(
        '_Z28nvshmemx_uint8_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_uint8_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_uint8_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_get_nbi_block, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_uint8_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_uint8_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_uint8_get_nbi_block_nbst(shim_stream, shim_obj)


def uint16_get_nbi_warp():
    pass
    

def _lower__Z28nvshmemx_uint16_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_uint16_get_nbi_warp_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint16_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_uint16_get_nbi_warp_nbst = declare_device(
        '_Z28nvshmemx_uint16_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_uint16_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_uint16_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_get_nbi_warp, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_uint16_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_uint16_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_uint16_get_nbi_warp_nbst(shim_stream, shim_obj)


def uint16_get_nbi_block():
    pass
    

def _lower__Z29nvshmemx_uint16_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_uint16_get_nbi_block_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint16_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_uint16_get_nbi_block_nbst = declare_device(
        '_Z29nvshmemx_uint16_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_uint16_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z29nvshmemx_uint16_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_get_nbi_block, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_uint16_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_uint16_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_uint16_get_nbi_block_nbst(shim_stream, shim_obj)


def uint32_get_nbi_warp():
    pass
    

def _lower__Z28nvshmemx_uint32_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_uint32_get_nbi_warp_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint32_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_uint32_get_nbi_warp_nbst = declare_device(
        '_Z28nvshmemx_uint32_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_uint32_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_uint32_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_get_nbi_warp, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_uint32_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_uint32_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_uint32_get_nbi_warp_nbst(shim_stream, shim_obj)


def uint32_get_nbi_block():
    pass
    

def _lower__Z29nvshmemx_uint32_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_uint32_get_nbi_block_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint32_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_uint32_get_nbi_block_nbst = declare_device(
        '_Z29nvshmemx_uint32_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_uint32_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z29nvshmemx_uint32_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_get_nbi_block, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_uint32_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_uint32_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_uint32_get_nbi_block_nbst(shim_stream, shim_obj)


def uint64_get_nbi_warp():
    pass
    

def _lower__Z28nvshmemx_uint64_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_uint64_get_nbi_warp_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint64_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_uint64_get_nbi_warp_nbst = declare_device(
        '_Z28nvshmemx_uint64_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_uint64_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z28nvshmemx_uint64_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_get_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_uint64_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_uint64_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_uint64_get_nbi_warp_nbst(shim_stream, shim_obj)


def uint64_get_nbi_block():
    pass
    

def _lower__Z29nvshmemx_uint64_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_uint64_get_nbi_block_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe) {
        nvshmemx_uint64_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_uint64_get_nbi_block_nbst = declare_device(
        '_Z29nvshmemx_uint64_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_uint64_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z29nvshmemx_uint64_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_get_nbi_block, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_uint64_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_uint64_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_uint64_get_nbi_block_nbst(shim_stream, shim_obj)


def size_get_nbi_warp():
    pass
    

def _lower__Z26nvshmemx_size_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_size_get_nbi_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_size_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_size_get_nbi_warp_nbst = declare_device(
        '_Z26nvshmemx_size_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_size_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z26nvshmemx_size_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_get_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_size_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_size_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_size_get_nbi_warp_nbst(shim_stream, shim_obj)


def size_get_nbi_block():
    pass
    

def _lower__Z27nvshmemx_size_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_size_get_nbi_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_size_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_size_get_nbi_block_nbst = declare_device(
        '_Z27nvshmemx_size_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_size_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z27nvshmemx_size_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_get_nbi_block, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_size_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_size_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_size_get_nbi_block_nbst(shim_stream, shim_obj)


def ptrdiff_get_nbi_warp():
    pass
    

def _lower__Z29nvshmemx_ptrdiff_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_ptrdiff_get_nbi_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ptrdiff_get_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_ptrdiff_get_nbi_warp_nbst = declare_device(
        '_Z29nvshmemx_ptrdiff_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_ptrdiff_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z29nvshmemx_ptrdiff_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ptrdiff_get_nbi_warp, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_ptrdiff_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_ptrdiff_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_ptrdiff_get_nbi_warp_nbst(shim_stream, shim_obj)


def ptrdiff_get_nbi_block():
    pass
    

def _lower__Z30nvshmemx_ptrdiff_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_ptrdiff_get_nbi_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe) {
        nvshmemx_ptrdiff_get_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z30nvshmemx_ptrdiff_get_nbi_block_nbst = declare_device(
        '_Z30nvshmemx_ptrdiff_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_ptrdiff_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z30nvshmemx_ptrdiff_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ptrdiff_get_nbi_block, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_ptrdiff_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_ptrdiff_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_ptrdiff_get_nbi_block_nbst(shim_stream, shim_obj)


def put8_nbi_warp():
    pass
    

def _lower__Z22nvshmemx_put8_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_put8_nbi_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put8_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_put8_nbi_warp_nbst = declare_device(
        '_Z22nvshmemx_put8_nbi_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_put8_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmemx_put8_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put8_nbi_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_put8_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_put8_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_put8_nbi_warp_nbst(shim_stream, shim_obj)


def put8_nbi_block():
    pass
    

def _lower__Z23nvshmemx_put8_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_put8_nbi_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put8_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_put8_nbi_block_nbst = declare_device(
        '_Z23nvshmemx_put8_nbi_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_put8_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_put8_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put8_nbi_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_put8_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_put8_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_put8_nbi_block_nbst(shim_stream, shim_obj)


def put16_nbi_warp():
    pass
    

def _lower__Z23nvshmemx_put16_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_put16_nbi_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put16_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_put16_nbi_warp_nbst = declare_device(
        '_Z23nvshmemx_put16_nbi_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_put16_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_put16_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put16_nbi_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_put16_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_put16_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_put16_nbi_warp_nbst(shim_stream, shim_obj)


def put16_nbi_block():
    pass
    

def _lower__Z24nvshmemx_put16_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_put16_nbi_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put16_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_put16_nbi_block_nbst = declare_device(
        '_Z24nvshmemx_put16_nbi_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_put16_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_put16_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put16_nbi_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_put16_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_put16_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_put16_nbi_block_nbst(shim_stream, shim_obj)


def put32_nbi_warp():
    pass
    

def _lower__Z23nvshmemx_put32_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_put32_nbi_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put32_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_put32_nbi_warp_nbst = declare_device(
        '_Z23nvshmemx_put32_nbi_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_put32_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_put32_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put32_nbi_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_put32_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_put32_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_put32_nbi_warp_nbst(shim_stream, shim_obj)


def put32_nbi_block():
    pass
    

def _lower__Z24nvshmemx_put32_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_put32_nbi_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put32_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_put32_nbi_block_nbst = declare_device(
        '_Z24nvshmemx_put32_nbi_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_put32_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_put32_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put32_nbi_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_put32_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_put32_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_put32_nbi_block_nbst(shim_stream, shim_obj)


def put64_nbi_warp():
    pass
    

def _lower__Z23nvshmemx_put64_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_put64_nbi_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put64_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_put64_nbi_warp_nbst = declare_device(
        '_Z23nvshmemx_put64_nbi_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_put64_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_put64_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put64_nbi_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_put64_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_put64_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_put64_nbi_warp_nbst(shim_stream, shim_obj)


def put64_nbi_block():
    pass
    

def _lower__Z24nvshmemx_put64_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_put64_nbi_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put64_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_put64_nbi_block_nbst = declare_device(
        '_Z24nvshmemx_put64_nbi_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_put64_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_put64_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put64_nbi_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_put64_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_put64_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_put64_nbi_block_nbst(shim_stream, shim_obj)


def put128_nbi_warp():
    pass
    

def _lower__Z24nvshmemx_put128_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_put128_nbi_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put128_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_put128_nbi_warp_nbst = declare_device(
        '_Z24nvshmemx_put128_nbi_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_put128_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_put128_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put128_nbi_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_put128_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_put128_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_put128_nbi_warp_nbst(shim_stream, shim_obj)


def put128_nbi_block():
    pass
    

def _lower__Z25nvshmemx_put128_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_put128_nbi_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_put128_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_put128_nbi_block_nbst = declare_device(
        '_Z25nvshmemx_put128_nbi_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_put128_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmemx_put128_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(put128_nbi_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_put128_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_put128_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_put128_nbi_block_nbst(shim_stream, shim_obj)


def get8_nbi_warp():
    pass
    

def _lower__Z22nvshmemx_get8_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_get8_nbi_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get8_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_get8_nbi_warp_nbst = declare_device(
        '_Z22nvshmemx_get8_nbi_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_get8_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmemx_get8_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get8_nbi_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_get8_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_get8_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_get8_nbi_warp_nbst(shim_stream, shim_obj)


def get8_nbi_block():
    pass
    

def _lower__Z23nvshmemx_get8_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_get8_nbi_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get8_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_get8_nbi_block_nbst = declare_device(
        '_Z23nvshmemx_get8_nbi_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_get8_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_get8_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get8_nbi_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_get8_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_get8_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_get8_nbi_block_nbst(shim_stream, shim_obj)


def get16_nbi_warp():
    pass
    

def _lower__Z23nvshmemx_get16_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_get16_nbi_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get16_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_get16_nbi_warp_nbst = declare_device(
        '_Z23nvshmemx_get16_nbi_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_get16_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_get16_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get16_nbi_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_get16_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_get16_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_get16_nbi_warp_nbst(shim_stream, shim_obj)


def get16_nbi_block():
    pass
    

def _lower__Z24nvshmemx_get16_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_get16_nbi_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get16_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_get16_nbi_block_nbst = declare_device(
        '_Z24nvshmemx_get16_nbi_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_get16_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_get16_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get16_nbi_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_get16_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_get16_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_get16_nbi_block_nbst(shim_stream, shim_obj)


def get32_nbi_warp():
    pass
    

def _lower__Z23nvshmemx_get32_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_get32_nbi_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get32_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_get32_nbi_warp_nbst = declare_device(
        '_Z23nvshmemx_get32_nbi_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_get32_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_get32_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get32_nbi_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_get32_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_get32_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_get32_nbi_warp_nbst(shim_stream, shim_obj)


def get32_nbi_block():
    pass
    

def _lower__Z24nvshmemx_get32_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_get32_nbi_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get32_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_get32_nbi_block_nbst = declare_device(
        '_Z24nvshmemx_get32_nbi_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_get32_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_get32_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get32_nbi_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_get32_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_get32_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_get32_nbi_block_nbst(shim_stream, shim_obj)


def get64_nbi_warp():
    pass
    

def _lower__Z23nvshmemx_get64_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_get64_nbi_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get64_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_get64_nbi_warp_nbst = declare_device(
        '_Z23nvshmemx_get64_nbi_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_get64_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_get64_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get64_nbi_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_get64_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_get64_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_get64_nbi_warp_nbst(shim_stream, shim_obj)


def get64_nbi_block():
    pass
    

def _lower__Z24nvshmemx_get64_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_get64_nbi_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get64_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_get64_nbi_block_nbst = declare_device(
        '_Z24nvshmemx_get64_nbi_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_get64_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_get64_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get64_nbi_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_get64_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_get64_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_get64_nbi_block_nbst(shim_stream, shim_obj)


def get128_nbi_warp():
    pass
    

def _lower__Z24nvshmemx_get128_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_get128_nbi_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get128_nbi_warp(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_get128_nbi_warp_nbst = declare_device(
        '_Z24nvshmemx_get128_nbi_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_get128_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_get128_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get128_nbi_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_get128_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_get128_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_get128_nbi_warp_nbst(shim_stream, shim_obj)


def get128_nbi_block():
    pass
    

def _lower__Z25nvshmemx_get128_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_get128_nbi_block_nbst(int &retval , void ** dest, void ** source, unsigned long* nelems, int* pe) {
        nvshmemx_get128_nbi_block(*dest, *source, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_get128_nbi_block_nbst = declare_device(
        '_Z25nvshmemx_get128_nbi_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_get128_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmemx_get128_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(get128_nbi_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_get128_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_get128_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_get128_nbi_block_nbst(shim_stream, shim_obj)


def putmem_nbi_warp():
    pass
    

def _lower__Z24nvshmemx_putmem_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_putmem_nbi_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* bytes, int* pe) {
        nvshmemx_putmem_nbi_warp(*dest, *source, *bytes, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_putmem_nbi_warp_nbst = declare_device(
        '_Z24nvshmemx_putmem_nbi_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_putmem_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_putmem_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(putmem_nbi_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_putmem_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_putmem_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_putmem_nbi_warp_nbst(shim_stream, shim_obj)


def putmem_nbi_block():
    pass
    

def _lower__Z25nvshmemx_putmem_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_putmem_nbi_block_nbst(int &retval , void ** dest, void ** source, unsigned long* bytes, int* pe) {
        nvshmemx_putmem_nbi_block(*dest, *source, *bytes, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_putmem_nbi_block_nbst = declare_device(
        '_Z25nvshmemx_putmem_nbi_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_putmem_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmemx_putmem_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(putmem_nbi_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_putmem_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_putmem_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_putmem_nbi_block_nbst(shim_stream, shim_obj)


def getmem_nbi_warp():
    pass
    

def _lower__Z24nvshmemx_getmem_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_getmem_nbi_warp_nbst(int &retval , void ** dest, void ** source, unsigned long* bytes, int* pe) {
        nvshmemx_getmem_nbi_warp(*dest, *source, *bytes, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_getmem_nbi_warp_nbst = declare_device(
        '_Z24nvshmemx_getmem_nbi_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_getmem_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z24nvshmemx_getmem_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(getmem_nbi_warp, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_getmem_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_getmem_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_getmem_nbi_warp_nbst(shim_stream, shim_obj)


def getmem_nbi_block():
    pass
    

def _lower__Z25nvshmemx_getmem_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_getmem_nbi_block_nbst(int &retval , void ** dest, void ** source, unsigned long* bytes, int* pe) {
        nvshmemx_getmem_nbi_block(*dest, *source, *bytes, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_getmem_nbi_block_nbst = declare_device(
        '_Z25nvshmemx_getmem_nbi_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_getmem_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z25nvshmemx_getmem_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(getmem_nbi_block, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_getmem_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_getmem_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_getmem_nbi_block_nbst(shim_stream, shim_obj)


def bfloat16_iput_warp():
    pass
    

def _lower__Z27nvshmemx_bfloat16_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_bfloat16_iput_warp_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_bfloat16_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_bfloat16_iput_warp_nbst = declare_device(
        '_Z27nvshmemx_bfloat16_iput_warp_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_bfloat16_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z27nvshmemx_bfloat16_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(bfloat16_iput_warp, CPointer(bfloat16), CPointer(bfloat16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_bfloat16_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_bfloat16_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_bfloat16_iput_warp_nbst(shim_stream, shim_obj)


def bfloat16_iput_block():
    pass
    

def _lower__Z28nvshmemx_bfloat16_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_bfloat16_iput_block_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_bfloat16_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_bfloat16_iput_block_nbst = declare_device(
        '_Z28nvshmemx_bfloat16_iput_block_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_bfloat16_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z28nvshmemx_bfloat16_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(bfloat16_iput_block, CPointer(bfloat16), CPointer(bfloat16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_bfloat16_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_bfloat16_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_bfloat16_iput_block_nbst(shim_stream, shim_obj)


def half_iput_warp():
    pass
    

def _lower__Z23nvshmemx_half_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_half_iput_warp_nbst(int &retval , __half ** dest, __half ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_half_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_half_iput_warp_nbst = declare_device(
        '_Z23nvshmemx_half_iput_warp_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_half_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z23nvshmemx_half_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(half_iput_warp, CPointer(float16), CPointer(float16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_half_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_half_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_half_iput_warp_nbst(shim_stream, shim_obj)


def half_iput_block():
    pass
    

def _lower__Z24nvshmemx_half_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_half_iput_block_nbst(int &retval , __half ** dest, __half ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_half_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_half_iput_block_nbst = declare_device(
        '_Z24nvshmemx_half_iput_block_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_half_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_half_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(half_iput_block, CPointer(float16), CPointer(float16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_half_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_half_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_half_iput_block_nbst(shim_stream, shim_obj)


def float_iput_warp():
    pass
    

def _lower__Z24nvshmemx_float_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_float_iput_warp_nbst(int &retval , float ** dest, float ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_float_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_float_iput_warp_nbst = declare_device(
        '_Z24nvshmemx_float_iput_warp_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_float_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_float_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(float_iput_warp, CPointer(float32), CPointer(float32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_float_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_float_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_float_iput_warp_nbst(shim_stream, shim_obj)


def float_iput_block():
    pass
    

def _lower__Z25nvshmemx_float_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_float_iput_block_nbst(int &retval , float ** dest, float ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_float_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_float_iput_block_nbst = declare_device(
        '_Z25nvshmemx_float_iput_block_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_float_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_float_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(float_iput_block, CPointer(float32), CPointer(float32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_float_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_float_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_float_iput_block_nbst(shim_stream, shim_obj)


def double_iput_warp():
    pass
    

def _lower__Z25nvshmemx_double_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_double_iput_warp_nbst(int &retval , double ** dest, double ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_double_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_double_iput_warp_nbst = declare_device(
        '_Z25nvshmemx_double_iput_warp_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_double_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_double_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(double_iput_warp, CPointer(float64), CPointer(float64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_double_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_double_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_double_iput_warp_nbst(shim_stream, shim_obj)


def double_iput_block():
    pass
    

def _lower__Z26nvshmemx_double_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_double_iput_block_nbst(int &retval , double ** dest, double ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_double_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_double_iput_block_nbst = declare_device(
        '_Z26nvshmemx_double_iput_block_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_double_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z26nvshmemx_double_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(double_iput_block, CPointer(float64), CPointer(float64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_double_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_double_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_double_iput_block_nbst(shim_stream, shim_obj)


def char_iput_warp():
    pass
    

def _lower__Z23nvshmemx_char_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_char_iput_warp_nbst(int &retval , char ** dest, char ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_char_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_char_iput_warp_nbst = declare_device(
        '_Z23nvshmemx_char_iput_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_char_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z23nvshmemx_char_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(char_iput_warp, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_char_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_char_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_char_iput_warp_nbst(shim_stream, shim_obj)


def char_iput_block():
    pass
    

def _lower__Z24nvshmemx_char_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_char_iput_block_nbst(int &retval , char ** dest, char ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_char_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_char_iput_block_nbst = declare_device(
        '_Z24nvshmemx_char_iput_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_char_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_char_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(char_iput_block, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_char_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_char_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_char_iput_block_nbst(shim_stream, shim_obj)


def short_iput_warp():
    pass
    

def _lower__Z24nvshmemx_short_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_short_iput_warp_nbst(int &retval , short ** dest, short ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_short_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_short_iput_warp_nbst = declare_device(
        '_Z24nvshmemx_short_iput_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_short_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_short_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(short_iput_warp, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_short_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_short_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_short_iput_warp_nbst(shim_stream, shim_obj)


def short_iput_block():
    pass
    

def _lower__Z25nvshmemx_short_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_short_iput_block_nbst(int &retval , short ** dest, short ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_short_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_short_iput_block_nbst = declare_device(
        '_Z25nvshmemx_short_iput_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_short_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_short_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(short_iput_block, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_short_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_short_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_short_iput_block_nbst(shim_stream, shim_obj)


def schar_iput_warp():
    pass
    

def _lower__Z24nvshmemx_schar_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_schar_iput_warp_nbst(int &retval , signed char ** dest, signed char ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_schar_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_schar_iput_warp_nbst = declare_device(
        '_Z24nvshmemx_schar_iput_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_schar_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_schar_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(schar_iput_warp, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_schar_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_schar_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_schar_iput_warp_nbst(shim_stream, shim_obj)


def schar_iput_block():
    pass
    

def _lower__Z25nvshmemx_schar_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_schar_iput_block_nbst(int &retval , signed char ** dest, signed char ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_schar_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_schar_iput_block_nbst = declare_device(
        '_Z25nvshmemx_schar_iput_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_schar_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_schar_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(schar_iput_block, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_schar_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_schar_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_schar_iput_block_nbst(shim_stream, shim_obj)


def int_iput_warp():
    pass
    

def _lower__Z22nvshmemx_int_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_int_iput_warp_nbst(int &retval , int ** dest, int ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_int_iput_warp_nbst = declare_device(
        '_Z22nvshmemx_int_iput_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_int_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z22nvshmemx_int_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int_iput_warp, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_int_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_int_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_int_iput_warp_nbst(shim_stream, shim_obj)


def int_iput_block():
    pass
    

def _lower__Z23nvshmemx_int_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_int_iput_block_nbst(int &retval , int ** dest, int ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_int_iput_block_nbst = declare_device(
        '_Z23nvshmemx_int_iput_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_int_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z23nvshmemx_int_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int_iput_block, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_int_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_int_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_int_iput_block_nbst(shim_stream, shim_obj)


def long_iput_warp():
    pass
    

def _lower__Z23nvshmemx_long_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_long_iput_warp_nbst(int &retval , long ** dest, long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_long_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_long_iput_warp_nbst = declare_device(
        '_Z23nvshmemx_long_iput_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_long_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z23nvshmemx_long_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(long_iput_warp, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_long_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_long_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_long_iput_warp_nbst(shim_stream, shim_obj)


def long_iput_block():
    pass
    

def _lower__Z24nvshmemx_long_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_long_iput_block_nbst(int &retval , long ** dest, long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_long_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_long_iput_block_nbst = declare_device(
        '_Z24nvshmemx_long_iput_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_long_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_long_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(long_iput_block, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_long_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_long_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_long_iput_block_nbst(shim_stream, shim_obj)


def longlong_iput_warp():
    pass
    

def _lower__Z27nvshmemx_longlong_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_longlong_iput_warp_nbst(int &retval , long long ** dest, long long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_longlong_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_longlong_iput_warp_nbst = declare_device(
        '_Z27nvshmemx_longlong_iput_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_longlong_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z27nvshmemx_longlong_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(longlong_iput_warp, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_longlong_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_longlong_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_longlong_iput_warp_nbst(shim_stream, shim_obj)


def longlong_iput_block():
    pass
    

def _lower__Z28nvshmemx_longlong_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_longlong_iput_block_nbst(int &retval , long long ** dest, long long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_longlong_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_longlong_iput_block_nbst = declare_device(
        '_Z28nvshmemx_longlong_iput_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_longlong_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z28nvshmemx_longlong_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(longlong_iput_block, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_longlong_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_longlong_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_longlong_iput_block_nbst(shim_stream, shim_obj)


def uchar_iput_warp():
    pass
    

def _lower__Z24nvshmemx_uchar_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_uchar_iput_warp_nbst(int &retval , unsigned char ** dest, unsigned char ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uchar_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_uchar_iput_warp_nbst = declare_device(
        '_Z24nvshmemx_uchar_iput_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_uchar_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_uchar_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uchar_iput_warp, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_uchar_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_uchar_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_uchar_iput_warp_nbst(shim_stream, shim_obj)


def uchar_iput_block():
    pass
    

def _lower__Z25nvshmemx_uchar_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_uchar_iput_block_nbst(int &retval , unsigned char ** dest, unsigned char ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uchar_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_uchar_iput_block_nbst = declare_device(
        '_Z25nvshmemx_uchar_iput_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_uchar_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_uchar_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uchar_iput_block, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_uchar_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_uchar_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_uchar_iput_block_nbst(shim_stream, shim_obj)


def ushort_iput_warp():
    pass
    

def _lower__Z25nvshmemx_ushort_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_ushort_iput_warp_nbst(int &retval , unsigned short ** dest, unsigned short ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_ushort_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_ushort_iput_warp_nbst = declare_device(
        '_Z25nvshmemx_ushort_iput_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_ushort_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_ushort_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ushort_iput_warp, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_ushort_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_ushort_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_ushort_iput_warp_nbst(shim_stream, shim_obj)


def ushort_iput_block():
    pass
    

def _lower__Z26nvshmemx_ushort_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_ushort_iput_block_nbst(int &retval , unsigned short ** dest, unsigned short ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_ushort_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_ushort_iput_block_nbst = declare_device(
        '_Z26nvshmemx_ushort_iput_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_ushort_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z26nvshmemx_ushort_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ushort_iput_block, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_ushort_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_ushort_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_ushort_iput_block_nbst(shim_stream, shim_obj)


def uint_iput_warp():
    pass
    

def _lower__Z23nvshmemx_uint_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_uint_iput_warp_nbst(int &retval , unsigned int ** dest, unsigned int ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_uint_iput_warp_nbst = declare_device(
        '_Z23nvshmemx_uint_iput_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_uint_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z23nvshmemx_uint_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint_iput_warp, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_uint_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_uint_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_uint_iput_warp_nbst(shim_stream, shim_obj)


def uint_iput_block():
    pass
    

def _lower__Z24nvshmemx_uint_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_uint_iput_block_nbst(int &retval , unsigned int ** dest, unsigned int ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_uint_iput_block_nbst = declare_device(
        '_Z24nvshmemx_uint_iput_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_uint_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_uint_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint_iput_block, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_uint_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_uint_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_uint_iput_block_nbst(shim_stream, shim_obj)


def ulong_iput_warp():
    pass
    

def _lower__Z24nvshmemx_ulong_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_ulong_iput_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_ulong_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_ulong_iput_warp_nbst = declare_device(
        '_Z24nvshmemx_ulong_iput_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_ulong_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_ulong_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulong_iput_warp, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_ulong_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_ulong_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_ulong_iput_warp_nbst(shim_stream, shim_obj)


def ulong_iput_block():
    pass
    

def _lower__Z25nvshmemx_ulong_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_ulong_iput_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_ulong_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_ulong_iput_block_nbst = declare_device(
        '_Z25nvshmemx_ulong_iput_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_ulong_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_ulong_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulong_iput_block, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_ulong_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_ulong_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_ulong_iput_block_nbst(shim_stream, shim_obj)


def ulonglong_iput_warp():
    pass
    

def _lower__Z28nvshmemx_ulonglong_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_ulonglong_iput_warp_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_ulonglong_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_ulonglong_iput_warp_nbst = declare_device(
        '_Z28nvshmemx_ulonglong_iput_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_ulonglong_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z28nvshmemx_ulonglong_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulonglong_iput_warp, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_ulonglong_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_ulonglong_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_ulonglong_iput_warp_nbst(shim_stream, shim_obj)


def ulonglong_iput_block():
    pass
    

def _lower__Z29nvshmemx_ulonglong_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_ulonglong_iput_block_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_ulonglong_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_ulonglong_iput_block_nbst = declare_device(
        '_Z29nvshmemx_ulonglong_iput_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_ulonglong_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z29nvshmemx_ulonglong_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulonglong_iput_block, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_ulonglong_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_ulonglong_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_ulonglong_iput_block_nbst(shim_stream, shim_obj)


def int8_iput_warp():
    pass
    

def _lower__Z23nvshmemx_int8_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_int8_iput_warp_nbst(int &retval , int8_t ** dest, int8_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int8_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_int8_iput_warp_nbst = declare_device(
        '_Z23nvshmemx_int8_iput_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_int8_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z23nvshmemx_int8_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int8_iput_warp, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_int8_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_int8_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_int8_iput_warp_nbst(shim_stream, shim_obj)


def int8_iput_block():
    pass
    

def _lower__Z24nvshmemx_int8_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_int8_iput_block_nbst(int &retval , int8_t ** dest, int8_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int8_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_int8_iput_block_nbst = declare_device(
        '_Z24nvshmemx_int8_iput_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_int8_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_int8_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int8_iput_block, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_int8_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_int8_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_int8_iput_block_nbst(shim_stream, shim_obj)


def int16_iput_warp():
    pass
    

def _lower__Z24nvshmemx_int16_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_int16_iput_warp_nbst(int &retval , int16_t ** dest, int16_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int16_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_int16_iput_warp_nbst = declare_device(
        '_Z24nvshmemx_int16_iput_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_int16_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_int16_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int16_iput_warp, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_int16_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_int16_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_int16_iput_warp_nbst(shim_stream, shim_obj)


def int16_iput_block():
    pass
    

def _lower__Z25nvshmemx_int16_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_int16_iput_block_nbst(int &retval , int16_t ** dest, int16_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int16_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_int16_iput_block_nbst = declare_device(
        '_Z25nvshmemx_int16_iput_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_int16_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_int16_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int16_iput_block, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_int16_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_int16_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_int16_iput_block_nbst(shim_stream, shim_obj)


def int32_iput_warp():
    pass
    

def _lower__Z24nvshmemx_int32_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_int32_iput_warp_nbst(int &retval , int32_t ** dest, int32_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int32_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_int32_iput_warp_nbst = declare_device(
        '_Z24nvshmemx_int32_iput_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_int32_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_int32_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int32_iput_warp, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_int32_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_int32_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_int32_iput_warp_nbst(shim_stream, shim_obj)


def int32_iput_block():
    pass
    

def _lower__Z25nvshmemx_int32_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_int32_iput_block_nbst(int &retval , int32_t ** dest, int32_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int32_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_int32_iput_block_nbst = declare_device(
        '_Z25nvshmemx_int32_iput_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_int32_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_int32_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int32_iput_block, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_int32_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_int32_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_int32_iput_block_nbst(shim_stream, shim_obj)


def int64_iput_warp():
    pass
    

def _lower__Z24nvshmemx_int64_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_int64_iput_warp_nbst(int &retval , int64_t ** dest, int64_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int64_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_int64_iput_warp_nbst = declare_device(
        '_Z24nvshmemx_int64_iput_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_int64_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_int64_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int64_iput_warp, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_int64_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_int64_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_int64_iput_warp_nbst(shim_stream, shim_obj)


def int64_iput_block():
    pass
    

def _lower__Z25nvshmemx_int64_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_int64_iput_block_nbst(int &retval , int64_t ** dest, int64_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int64_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_int64_iput_block_nbst = declare_device(
        '_Z25nvshmemx_int64_iput_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_int64_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_int64_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int64_iput_block, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_int64_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_int64_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_int64_iput_block_nbst(shim_stream, shim_obj)


def uint8_iput_warp():
    pass
    

def _lower__Z24nvshmemx_uint8_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_uint8_iput_warp_nbst(int &retval , uint8_t ** dest, uint8_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint8_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_uint8_iput_warp_nbst = declare_device(
        '_Z24nvshmemx_uint8_iput_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_uint8_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_uint8_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint8_iput_warp, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_uint8_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_uint8_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_uint8_iput_warp_nbst(shim_stream, shim_obj)


def uint8_iput_block():
    pass
    

def _lower__Z25nvshmemx_uint8_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_uint8_iput_block_nbst(int &retval , uint8_t ** dest, uint8_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint8_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_uint8_iput_block_nbst = declare_device(
        '_Z25nvshmemx_uint8_iput_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_uint8_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_uint8_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint8_iput_block, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_uint8_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_uint8_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_uint8_iput_block_nbst(shim_stream, shim_obj)


def uint16_iput_warp():
    pass
    

def _lower__Z25nvshmemx_uint16_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_uint16_iput_warp_nbst(int &retval , uint16_t ** dest, uint16_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint16_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_uint16_iput_warp_nbst = declare_device(
        '_Z25nvshmemx_uint16_iput_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_uint16_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_uint16_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint16_iput_warp, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_uint16_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_uint16_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_uint16_iput_warp_nbst(shim_stream, shim_obj)


def uint16_iput_block():
    pass
    

def _lower__Z26nvshmemx_uint16_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_uint16_iput_block_nbst(int &retval , uint16_t ** dest, uint16_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint16_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_uint16_iput_block_nbst = declare_device(
        '_Z26nvshmemx_uint16_iput_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_uint16_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z26nvshmemx_uint16_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint16_iput_block, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_uint16_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_uint16_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_uint16_iput_block_nbst(shim_stream, shim_obj)


def uint32_iput_warp():
    pass
    

def _lower__Z25nvshmemx_uint32_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_uint32_iput_warp_nbst(int &retval , uint32_t ** dest, uint32_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint32_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_uint32_iput_warp_nbst = declare_device(
        '_Z25nvshmemx_uint32_iput_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_uint32_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_uint32_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint32_iput_warp, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_uint32_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_uint32_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_uint32_iput_warp_nbst(shim_stream, shim_obj)


def uint32_iput_block():
    pass
    

def _lower__Z26nvshmemx_uint32_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_uint32_iput_block_nbst(int &retval , uint32_t ** dest, uint32_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint32_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_uint32_iput_block_nbst = declare_device(
        '_Z26nvshmemx_uint32_iput_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_uint32_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z26nvshmemx_uint32_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint32_iput_block, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_uint32_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_uint32_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_uint32_iput_block_nbst(shim_stream, shim_obj)


def uint64_iput_warp():
    pass
    

def _lower__Z25nvshmemx_uint64_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_uint64_iput_warp_nbst(int &retval , uint64_t ** dest, uint64_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint64_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_uint64_iput_warp_nbst = declare_device(
        '_Z25nvshmemx_uint64_iput_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_uint64_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_uint64_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint64_iput_warp, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_uint64_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_uint64_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_uint64_iput_warp_nbst(shim_stream, shim_obj)


def uint64_iput_block():
    pass
    

def _lower__Z26nvshmemx_uint64_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_uint64_iput_block_nbst(int &retval , uint64_t ** dest, uint64_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint64_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_uint64_iput_block_nbst = declare_device(
        '_Z26nvshmemx_uint64_iput_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_uint64_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z26nvshmemx_uint64_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint64_iput_block, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_uint64_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_uint64_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_uint64_iput_block_nbst(shim_stream, shim_obj)


def size_iput_warp():
    pass
    

def _lower__Z23nvshmemx_size_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_size_iput_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_size_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_size_iput_warp_nbst = declare_device(
        '_Z23nvshmemx_size_iput_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_size_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z23nvshmemx_size_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(size_iput_warp, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_size_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_size_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_size_iput_warp_nbst(shim_stream, shim_obj)


def size_iput_block():
    pass
    

def _lower__Z24nvshmemx_size_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_size_iput_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_size_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_size_iput_block_nbst = declare_device(
        '_Z24nvshmemx_size_iput_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_size_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_size_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(size_iput_block, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_size_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_size_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_size_iput_block_nbst(shim_stream, shim_obj)


def ptrdiff_iput_warp():
    pass
    

def _lower__Z26nvshmemx_ptrdiff_iput_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_ptrdiff_iput_warp_nbst(int &retval , long ** dest, long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_ptrdiff_iput_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_ptrdiff_iput_warp_nbst = declare_device(
        '_Z26nvshmemx_ptrdiff_iput_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_ptrdiff_iput_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z26nvshmemx_ptrdiff_iput_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ptrdiff_iput_warp, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_ptrdiff_iput_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_ptrdiff_iput_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_ptrdiff_iput_warp_nbst(shim_stream, shim_obj)


def ptrdiff_iput_block():
    pass
    

def _lower__Z27nvshmemx_ptrdiff_iput_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_ptrdiff_iput_block_nbst(int &retval , long ** dest, long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_ptrdiff_iput_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_ptrdiff_iput_block_nbst = declare_device(
        '_Z27nvshmemx_ptrdiff_iput_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_ptrdiff_iput_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z27nvshmemx_ptrdiff_iput_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ptrdiff_iput_block, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_ptrdiff_iput_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_ptrdiff_iput_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_ptrdiff_iput_block_nbst(shim_stream, shim_obj)


def iput8_warp():
    pass
    

def _lower__Z19nvshmemx_iput8_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_iput8_warp_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iput8_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmemx_iput8_warp_nbst = declare_device(
        '_Z19nvshmemx_iput8_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_iput8_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z19nvshmemx_iput8_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iput8_warp, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_iput8_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_iput8_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_iput8_warp_nbst(shim_stream, shim_obj)


def iput8_block():
    pass
    

def _lower__Z20nvshmemx_iput8_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_iput8_block_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iput8_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmemx_iput8_block_nbst = declare_device(
        '_Z20nvshmemx_iput8_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_iput8_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z20nvshmemx_iput8_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iput8_block, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_iput8_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_iput8_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_iput8_block_nbst(shim_stream, shim_obj)


def iput16_warp():
    pass
    

def _lower__Z20nvshmemx_iput16_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_iput16_warp_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iput16_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmemx_iput16_warp_nbst = declare_device(
        '_Z20nvshmemx_iput16_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_iput16_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z20nvshmemx_iput16_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iput16_warp, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_iput16_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_iput16_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_iput16_warp_nbst(shim_stream, shim_obj)


def iput16_block():
    pass
    

def _lower__Z21nvshmemx_iput16_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_iput16_block_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iput16_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmemx_iput16_block_nbst = declare_device(
        '_Z21nvshmemx_iput16_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_iput16_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z21nvshmemx_iput16_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iput16_block, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_iput16_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_iput16_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_iput16_block_nbst(shim_stream, shim_obj)


def iput32_warp():
    pass
    

def _lower__Z20nvshmemx_iput32_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_iput32_warp_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iput32_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmemx_iput32_warp_nbst = declare_device(
        '_Z20nvshmemx_iput32_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_iput32_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z20nvshmemx_iput32_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iput32_warp, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_iput32_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_iput32_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_iput32_warp_nbst(shim_stream, shim_obj)


def iput32_block():
    pass
    

def _lower__Z21nvshmemx_iput32_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_iput32_block_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iput32_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmemx_iput32_block_nbst = declare_device(
        '_Z21nvshmemx_iput32_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_iput32_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z21nvshmemx_iput32_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iput32_block, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_iput32_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_iput32_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_iput32_block_nbst(shim_stream, shim_obj)


def iput64_warp():
    pass
    

def _lower__Z20nvshmemx_iput64_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_iput64_warp_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iput64_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmemx_iput64_warp_nbst = declare_device(
        '_Z20nvshmemx_iput64_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_iput64_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z20nvshmemx_iput64_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iput64_warp, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_iput64_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_iput64_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_iput64_warp_nbst(shim_stream, shim_obj)


def iput64_block():
    pass
    

def _lower__Z21nvshmemx_iput64_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_iput64_block_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iput64_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmemx_iput64_block_nbst = declare_device(
        '_Z21nvshmemx_iput64_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_iput64_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z21nvshmemx_iput64_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iput64_block, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_iput64_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_iput64_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_iput64_block_nbst(shim_stream, shim_obj)


def iput128_warp():
    pass
    

def _lower__Z21nvshmemx_iput128_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_iput128_warp_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iput128_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmemx_iput128_warp_nbst = declare_device(
        '_Z21nvshmemx_iput128_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_iput128_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z21nvshmemx_iput128_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iput128_warp, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_iput128_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_iput128_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_iput128_warp_nbst(shim_stream, shim_obj)


def iput128_block():
    pass
    

def _lower__Z22nvshmemx_iput128_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_iput128_block_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iput128_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_iput128_block_nbst = declare_device(
        '_Z22nvshmemx_iput128_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_iput128_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z22nvshmemx_iput128_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iput128_block, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_iput128_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_iput128_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_iput128_block_nbst(shim_stream, shim_obj)


def bfloat16_iget_warp():
    pass
    

def _lower__Z27nvshmemx_bfloat16_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_bfloat16_iget_warp_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_bfloat16_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_bfloat16_iget_warp_nbst = declare_device(
        '_Z27nvshmemx_bfloat16_iget_warp_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_bfloat16_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z27nvshmemx_bfloat16_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(bfloat16_iget_warp, CPointer(bfloat16), CPointer(bfloat16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_bfloat16_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_bfloat16_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_bfloat16_iget_warp_nbst(shim_stream, shim_obj)


def bfloat16_iget_block():
    pass
    

def _lower__Z28nvshmemx_bfloat16_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_bfloat16_iget_block_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_bfloat16_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_bfloat16_iget_block_nbst = declare_device(
        '_Z28nvshmemx_bfloat16_iget_block_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_bfloat16_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z28nvshmemx_bfloat16_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(bfloat16_iget_block, CPointer(bfloat16), CPointer(bfloat16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_bfloat16_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_bfloat16_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_bfloat16_iget_block_nbst(shim_stream, shim_obj)


def half_iget_warp():
    pass
    

def _lower__Z23nvshmemx_half_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_half_iget_warp_nbst(int &retval , __half ** dest, __half ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_half_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_half_iget_warp_nbst = declare_device(
        '_Z23nvshmemx_half_iget_warp_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_half_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z23nvshmemx_half_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(half_iget_warp, CPointer(float16), CPointer(float16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_half_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_half_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_half_iget_warp_nbst(shim_stream, shim_obj)


def half_iget_block():
    pass
    

def _lower__Z24nvshmemx_half_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_half_iget_block_nbst(int &retval , __half ** dest, __half ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_half_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_half_iget_block_nbst = declare_device(
        '_Z24nvshmemx_half_iget_block_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_half_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_half_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(half_iget_block, CPointer(float16), CPointer(float16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_half_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_half_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_half_iget_block_nbst(shim_stream, shim_obj)


def float_iget_warp():
    pass
    

def _lower__Z24nvshmemx_float_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_float_iget_warp_nbst(int &retval , float ** dest, float ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_float_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_float_iget_warp_nbst = declare_device(
        '_Z24nvshmemx_float_iget_warp_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_float_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_float_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(float_iget_warp, CPointer(float32), CPointer(float32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_float_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_float_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_float_iget_warp_nbst(shim_stream, shim_obj)


def float_iget_block():
    pass
    

def _lower__Z25nvshmemx_float_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_float_iget_block_nbst(int &retval , float ** dest, float ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_float_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_float_iget_block_nbst = declare_device(
        '_Z25nvshmemx_float_iget_block_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_float_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_float_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(float_iget_block, CPointer(float32), CPointer(float32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_float_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_float_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_float_iget_block_nbst(shim_stream, shim_obj)


def double_iget_warp():
    pass
    

def _lower__Z25nvshmemx_double_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_double_iget_warp_nbst(int &retval , double ** dest, double ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_double_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_double_iget_warp_nbst = declare_device(
        '_Z25nvshmemx_double_iget_warp_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_double_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_double_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(double_iget_warp, CPointer(float64), CPointer(float64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_double_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_double_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_double_iget_warp_nbst(shim_stream, shim_obj)


def double_iget_block():
    pass
    

def _lower__Z26nvshmemx_double_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_double_iget_block_nbst(int &retval , double ** dest, double ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_double_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_double_iget_block_nbst = declare_device(
        '_Z26nvshmemx_double_iget_block_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_double_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z26nvshmemx_double_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(double_iget_block, CPointer(float64), CPointer(float64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_double_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_double_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_double_iget_block_nbst(shim_stream, shim_obj)


def char_iget_warp():
    pass
    

def _lower__Z23nvshmemx_char_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_char_iget_warp_nbst(int &retval , char ** dest, char ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_char_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_char_iget_warp_nbst = declare_device(
        '_Z23nvshmemx_char_iget_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_char_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z23nvshmemx_char_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(char_iget_warp, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_char_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_char_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_char_iget_warp_nbst(shim_stream, shim_obj)


def char_iget_block():
    pass
    

def _lower__Z24nvshmemx_char_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_char_iget_block_nbst(int &retval , char ** dest, char ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_char_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_char_iget_block_nbst = declare_device(
        '_Z24nvshmemx_char_iget_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_char_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_char_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(char_iget_block, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_char_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_char_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_char_iget_block_nbst(shim_stream, shim_obj)


def short_iget_warp():
    pass
    

def _lower__Z24nvshmemx_short_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_short_iget_warp_nbst(int &retval , short ** dest, short ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_short_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_short_iget_warp_nbst = declare_device(
        '_Z24nvshmemx_short_iget_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_short_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_short_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(short_iget_warp, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_short_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_short_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_short_iget_warp_nbst(shim_stream, shim_obj)


def short_iget_block():
    pass
    

def _lower__Z25nvshmemx_short_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_short_iget_block_nbst(int &retval , short ** dest, short ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_short_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_short_iget_block_nbst = declare_device(
        '_Z25nvshmemx_short_iget_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_short_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_short_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(short_iget_block, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_short_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_short_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_short_iget_block_nbst(shim_stream, shim_obj)


def schar_iget_warp():
    pass
    

def _lower__Z24nvshmemx_schar_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_schar_iget_warp_nbst(int &retval , signed char ** dest, signed char ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_schar_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_schar_iget_warp_nbst = declare_device(
        '_Z24nvshmemx_schar_iget_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_schar_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_schar_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(schar_iget_warp, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_schar_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_schar_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_schar_iget_warp_nbst(shim_stream, shim_obj)


def schar_iget_block():
    pass
    

def _lower__Z25nvshmemx_schar_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_schar_iget_block_nbst(int &retval , signed char ** dest, signed char ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_schar_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_schar_iget_block_nbst = declare_device(
        '_Z25nvshmemx_schar_iget_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_schar_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_schar_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(schar_iget_block, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_schar_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_schar_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_schar_iget_block_nbst(shim_stream, shim_obj)


def int_iget_warp():
    pass
    

def _lower__Z22nvshmemx_int_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_int_iget_warp_nbst(int &retval , int ** dest, int ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_int_iget_warp_nbst = declare_device(
        '_Z22nvshmemx_int_iget_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_int_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z22nvshmemx_int_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int_iget_warp, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_int_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_int_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_int_iget_warp_nbst(shim_stream, shim_obj)


def int_iget_block():
    pass
    

def _lower__Z23nvshmemx_int_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_int_iget_block_nbst(int &retval , int ** dest, int ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_int_iget_block_nbst = declare_device(
        '_Z23nvshmemx_int_iget_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_int_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z23nvshmemx_int_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int_iget_block, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_int_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_int_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_int_iget_block_nbst(shim_stream, shim_obj)


def long_iget_warp():
    pass
    

def _lower__Z23nvshmemx_long_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_long_iget_warp_nbst(int &retval , long ** dest, long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_long_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_long_iget_warp_nbst = declare_device(
        '_Z23nvshmemx_long_iget_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_long_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z23nvshmemx_long_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(long_iget_warp, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_long_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_long_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_long_iget_warp_nbst(shim_stream, shim_obj)


def long_iget_block():
    pass
    

def _lower__Z24nvshmemx_long_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_long_iget_block_nbst(int &retval , long ** dest, long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_long_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_long_iget_block_nbst = declare_device(
        '_Z24nvshmemx_long_iget_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_long_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_long_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(long_iget_block, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_long_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_long_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_long_iget_block_nbst(shim_stream, shim_obj)


def longlong_iget_warp():
    pass
    

def _lower__Z27nvshmemx_longlong_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_longlong_iget_warp_nbst(int &retval , long long ** dest, long long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_longlong_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_longlong_iget_warp_nbst = declare_device(
        '_Z27nvshmemx_longlong_iget_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_longlong_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z27nvshmemx_longlong_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(longlong_iget_warp, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_longlong_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_longlong_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_longlong_iget_warp_nbst(shim_stream, shim_obj)


def longlong_iget_block():
    pass
    

def _lower__Z28nvshmemx_longlong_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_longlong_iget_block_nbst(int &retval , long long ** dest, long long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_longlong_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_longlong_iget_block_nbst = declare_device(
        '_Z28nvshmemx_longlong_iget_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_longlong_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z28nvshmemx_longlong_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(longlong_iget_block, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_longlong_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_longlong_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_longlong_iget_block_nbst(shim_stream, shim_obj)


def uchar_iget_warp():
    pass
    

def _lower__Z24nvshmemx_uchar_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_uchar_iget_warp_nbst(int &retval , unsigned char ** dest, unsigned char ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uchar_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_uchar_iget_warp_nbst = declare_device(
        '_Z24nvshmemx_uchar_iget_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_uchar_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_uchar_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uchar_iget_warp, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_uchar_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_uchar_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_uchar_iget_warp_nbst(shim_stream, shim_obj)


def uchar_iget_block():
    pass
    

def _lower__Z25nvshmemx_uchar_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_uchar_iget_block_nbst(int &retval , unsigned char ** dest, unsigned char ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uchar_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_uchar_iget_block_nbst = declare_device(
        '_Z25nvshmemx_uchar_iget_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_uchar_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_uchar_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uchar_iget_block, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_uchar_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_uchar_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_uchar_iget_block_nbst(shim_stream, shim_obj)


def ushort_iget_warp():
    pass
    

def _lower__Z25nvshmemx_ushort_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_ushort_iget_warp_nbst(int &retval , unsigned short ** dest, unsigned short ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_ushort_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_ushort_iget_warp_nbst = declare_device(
        '_Z25nvshmemx_ushort_iget_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_ushort_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_ushort_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ushort_iget_warp, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_ushort_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_ushort_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_ushort_iget_warp_nbst(shim_stream, shim_obj)


def ushort_iget_block():
    pass
    

def _lower__Z26nvshmemx_ushort_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_ushort_iget_block_nbst(int &retval , unsigned short ** dest, unsigned short ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_ushort_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_ushort_iget_block_nbst = declare_device(
        '_Z26nvshmemx_ushort_iget_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_ushort_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z26nvshmemx_ushort_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ushort_iget_block, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_ushort_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_ushort_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_ushort_iget_block_nbst(shim_stream, shim_obj)


def uint_iget_warp():
    pass
    

def _lower__Z23nvshmemx_uint_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_uint_iget_warp_nbst(int &retval , unsigned int ** dest, unsigned int ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_uint_iget_warp_nbst = declare_device(
        '_Z23nvshmemx_uint_iget_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_uint_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z23nvshmemx_uint_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint_iget_warp, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_uint_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_uint_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_uint_iget_warp_nbst(shim_stream, shim_obj)


def uint_iget_block():
    pass
    

def _lower__Z24nvshmemx_uint_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_uint_iget_block_nbst(int &retval , unsigned int ** dest, unsigned int ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_uint_iget_block_nbst = declare_device(
        '_Z24nvshmemx_uint_iget_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_uint_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_uint_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint_iget_block, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_uint_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_uint_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_uint_iget_block_nbst(shim_stream, shim_obj)


def ulong_iget_warp():
    pass
    

def _lower__Z24nvshmemx_ulong_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_ulong_iget_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_ulong_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_ulong_iget_warp_nbst = declare_device(
        '_Z24nvshmemx_ulong_iget_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_ulong_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_ulong_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulong_iget_warp, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_ulong_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_ulong_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_ulong_iget_warp_nbst(shim_stream, shim_obj)


def ulong_iget_block():
    pass
    

def _lower__Z25nvshmemx_ulong_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_ulong_iget_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_ulong_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_ulong_iget_block_nbst = declare_device(
        '_Z25nvshmemx_ulong_iget_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_ulong_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_ulong_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulong_iget_block, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_ulong_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_ulong_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_ulong_iget_block_nbst(shim_stream, shim_obj)


def ulonglong_iget_warp():
    pass
    

def _lower__Z28nvshmemx_ulonglong_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_ulonglong_iget_warp_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_ulonglong_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z28nvshmemx_ulonglong_iget_warp_nbst = declare_device(
        '_Z28nvshmemx_ulonglong_iget_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_ulonglong_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z28nvshmemx_ulonglong_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulonglong_iget_warp, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_ulonglong_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_ulonglong_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_ulonglong_iget_warp_nbst(shim_stream, shim_obj)


def ulonglong_iget_block():
    pass
    

def _lower__Z29nvshmemx_ulonglong_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_ulonglong_iget_block_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_ulonglong_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z29nvshmemx_ulonglong_iget_block_nbst = declare_device(
        '_Z29nvshmemx_ulonglong_iget_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_ulonglong_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z29nvshmemx_ulonglong_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ulonglong_iget_block, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_ulonglong_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_ulonglong_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_ulonglong_iget_block_nbst(shim_stream, shim_obj)


def int8_iget_warp():
    pass
    

def _lower__Z23nvshmemx_int8_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_int8_iget_warp_nbst(int &retval , int8_t ** dest, int8_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int8_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_int8_iget_warp_nbst = declare_device(
        '_Z23nvshmemx_int8_iget_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_int8_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z23nvshmemx_int8_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int8_iget_warp, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_int8_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_int8_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_int8_iget_warp_nbst(shim_stream, shim_obj)


def int8_iget_block():
    pass
    

def _lower__Z24nvshmemx_int8_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_int8_iget_block_nbst(int &retval , int8_t ** dest, int8_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int8_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_int8_iget_block_nbst = declare_device(
        '_Z24nvshmemx_int8_iget_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_int8_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_int8_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int8_iget_block, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_int8_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_int8_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_int8_iget_block_nbst(shim_stream, shim_obj)


def int16_iget_warp():
    pass
    

def _lower__Z24nvshmemx_int16_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_int16_iget_warp_nbst(int &retval , int16_t ** dest, int16_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int16_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_int16_iget_warp_nbst = declare_device(
        '_Z24nvshmemx_int16_iget_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_int16_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_int16_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int16_iget_warp, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_int16_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_int16_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_int16_iget_warp_nbst(shim_stream, shim_obj)


def int16_iget_block():
    pass
    

def _lower__Z25nvshmemx_int16_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_int16_iget_block_nbst(int &retval , int16_t ** dest, int16_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int16_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_int16_iget_block_nbst = declare_device(
        '_Z25nvshmemx_int16_iget_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_int16_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_int16_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int16_iget_block, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_int16_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_int16_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_int16_iget_block_nbst(shim_stream, shim_obj)


def int32_iget_warp():
    pass
    

def _lower__Z24nvshmemx_int32_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_int32_iget_warp_nbst(int &retval , int32_t ** dest, int32_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int32_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_int32_iget_warp_nbst = declare_device(
        '_Z24nvshmemx_int32_iget_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_int32_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_int32_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int32_iget_warp, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_int32_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_int32_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_int32_iget_warp_nbst(shim_stream, shim_obj)


def int32_iget_block():
    pass
    

def _lower__Z25nvshmemx_int32_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_int32_iget_block_nbst(int &retval , int32_t ** dest, int32_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int32_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_int32_iget_block_nbst = declare_device(
        '_Z25nvshmemx_int32_iget_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_int32_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_int32_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int32_iget_block, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_int32_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_int32_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_int32_iget_block_nbst(shim_stream, shim_obj)


def int64_iget_warp():
    pass
    

def _lower__Z24nvshmemx_int64_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_int64_iget_warp_nbst(int &retval , int64_t ** dest, int64_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int64_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_int64_iget_warp_nbst = declare_device(
        '_Z24nvshmemx_int64_iget_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_int64_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_int64_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int64_iget_warp, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_int64_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_int64_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_int64_iget_warp_nbst(shim_stream, shim_obj)


def int64_iget_block():
    pass
    

def _lower__Z25nvshmemx_int64_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_int64_iget_block_nbst(int &retval , int64_t ** dest, int64_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_int64_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_int64_iget_block_nbst = declare_device(
        '_Z25nvshmemx_int64_iget_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_int64_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_int64_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(int64_iget_block, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_int64_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_int64_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_int64_iget_block_nbst(shim_stream, shim_obj)


def uint8_iget_warp():
    pass
    

def _lower__Z24nvshmemx_uint8_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_uint8_iget_warp_nbst(int &retval , uint8_t ** dest, uint8_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint8_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_uint8_iget_warp_nbst = declare_device(
        '_Z24nvshmemx_uint8_iget_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_uint8_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_uint8_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint8_iget_warp, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_uint8_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_uint8_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_uint8_iget_warp_nbst(shim_stream, shim_obj)


def uint8_iget_block():
    pass
    

def _lower__Z25nvshmemx_uint8_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_uint8_iget_block_nbst(int &retval , uint8_t ** dest, uint8_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint8_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_uint8_iget_block_nbst = declare_device(
        '_Z25nvshmemx_uint8_iget_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_uint8_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_uint8_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint8_iget_block, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_uint8_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_uint8_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_uint8_iget_block_nbst(shim_stream, shim_obj)


def uint16_iget_warp():
    pass
    

def _lower__Z25nvshmemx_uint16_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_uint16_iget_warp_nbst(int &retval , uint16_t ** dest, uint16_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint16_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_uint16_iget_warp_nbst = declare_device(
        '_Z25nvshmemx_uint16_iget_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_uint16_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_uint16_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint16_iget_warp, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_uint16_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_uint16_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_uint16_iget_warp_nbst(shim_stream, shim_obj)


def uint16_iget_block():
    pass
    

def _lower__Z26nvshmemx_uint16_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_uint16_iget_block_nbst(int &retval , uint16_t ** dest, uint16_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint16_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_uint16_iget_block_nbst = declare_device(
        '_Z26nvshmemx_uint16_iget_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_uint16_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z26nvshmemx_uint16_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint16_iget_block, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_uint16_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_uint16_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_uint16_iget_block_nbst(shim_stream, shim_obj)


def uint32_iget_warp():
    pass
    

def _lower__Z25nvshmemx_uint32_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_uint32_iget_warp_nbst(int &retval , uint32_t ** dest, uint32_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint32_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_uint32_iget_warp_nbst = declare_device(
        '_Z25nvshmemx_uint32_iget_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_uint32_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_uint32_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint32_iget_warp, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_uint32_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_uint32_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_uint32_iget_warp_nbst(shim_stream, shim_obj)


def uint32_iget_block():
    pass
    

def _lower__Z26nvshmemx_uint32_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_uint32_iget_block_nbst(int &retval , uint32_t ** dest, uint32_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint32_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_uint32_iget_block_nbst = declare_device(
        '_Z26nvshmemx_uint32_iget_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_uint32_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z26nvshmemx_uint32_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint32_iget_block, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_uint32_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_uint32_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_uint32_iget_block_nbst(shim_stream, shim_obj)


def uint64_iget_warp():
    pass
    

def _lower__Z25nvshmemx_uint64_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_uint64_iget_warp_nbst(int &retval , uint64_t ** dest, uint64_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint64_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z25nvshmemx_uint64_iget_warp_nbst = declare_device(
        '_Z25nvshmemx_uint64_iget_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_uint64_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z25nvshmemx_uint64_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint64_iget_warp, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_uint64_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_uint64_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_uint64_iget_warp_nbst(shim_stream, shim_obj)


def uint64_iget_block():
    pass
    

def _lower__Z26nvshmemx_uint64_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_uint64_iget_block_nbst(int &retval , uint64_t ** dest, uint64_t ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_uint64_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_uint64_iget_block_nbst = declare_device(
        '_Z26nvshmemx_uint64_iget_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_uint64_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z26nvshmemx_uint64_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(uint64_iget_block, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_uint64_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_uint64_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_uint64_iget_block_nbst(shim_stream, shim_obj)


def size_iget_warp():
    pass
    

def _lower__Z23nvshmemx_size_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_size_iget_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_size_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z23nvshmemx_size_iget_warp_nbst = declare_device(
        '_Z23nvshmemx_size_iget_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_size_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z23nvshmemx_size_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(size_iget_warp, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_size_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_size_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_size_iget_warp_nbst(shim_stream, shim_obj)


def size_iget_block():
    pass
    

def _lower__Z24nvshmemx_size_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_size_iget_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_size_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z24nvshmemx_size_iget_block_nbst = declare_device(
        '_Z24nvshmemx_size_iget_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_size_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z24nvshmemx_size_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(size_iget_block, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_size_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_size_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_size_iget_block_nbst(shim_stream, shim_obj)


def ptrdiff_iget_warp():
    pass
    

def _lower__Z26nvshmemx_ptrdiff_iget_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_ptrdiff_iget_warp_nbst(int &retval , long ** dest, long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_ptrdiff_iget_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z26nvshmemx_ptrdiff_iget_warp_nbst = declare_device(
        '_Z26nvshmemx_ptrdiff_iget_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_ptrdiff_iget_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z26nvshmemx_ptrdiff_iget_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ptrdiff_iget_warp, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_ptrdiff_iget_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_ptrdiff_iget_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_ptrdiff_iget_warp_nbst(shim_stream, shim_obj)


def ptrdiff_iget_block():
    pass
    

def _lower__Z27nvshmemx_ptrdiff_iget_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_ptrdiff_iget_block_nbst(int &retval , long ** dest, long ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_ptrdiff_iget_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z27nvshmemx_ptrdiff_iget_block_nbst = declare_device(
        '_Z27nvshmemx_ptrdiff_iget_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_ptrdiff_iget_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z27nvshmemx_ptrdiff_iget_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(ptrdiff_iget_block, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_ptrdiff_iget_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_ptrdiff_iget_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_ptrdiff_iget_block_nbst(shim_stream, shim_obj)


def iget8_warp():
    pass
    

def _lower__Z19nvshmemx_iget8_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_iget8_warp_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iget8_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z19nvshmemx_iget8_warp_nbst = declare_device(
        '_Z19nvshmemx_iget8_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_iget8_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z19nvshmemx_iget8_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iget8_warp, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_iget8_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_iget8_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_iget8_warp_nbst(shim_stream, shim_obj)


def iget8_block():
    pass
    

def _lower__Z20nvshmemx_iget8_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_iget8_block_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iget8_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmemx_iget8_block_nbst = declare_device(
        '_Z20nvshmemx_iget8_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_iget8_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z20nvshmemx_iget8_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iget8_block, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_iget8_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_iget8_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_iget8_block_nbst(shim_stream, shim_obj)


def iget16_warp():
    pass
    

def _lower__Z20nvshmemx_iget16_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_iget16_warp_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iget16_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmemx_iget16_warp_nbst = declare_device(
        '_Z20nvshmemx_iget16_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_iget16_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z20nvshmemx_iget16_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iget16_warp, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_iget16_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_iget16_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_iget16_warp_nbst(shim_stream, shim_obj)


def iget16_block():
    pass
    

def _lower__Z21nvshmemx_iget16_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_iget16_block_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iget16_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmemx_iget16_block_nbst = declare_device(
        '_Z21nvshmemx_iget16_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_iget16_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z21nvshmemx_iget16_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iget16_block, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_iget16_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_iget16_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_iget16_block_nbst(shim_stream, shim_obj)


def iget32_warp():
    pass
    

def _lower__Z20nvshmemx_iget32_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_iget32_warp_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iget32_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmemx_iget32_warp_nbst = declare_device(
        '_Z20nvshmemx_iget32_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_iget32_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z20nvshmemx_iget32_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iget32_warp, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_iget32_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_iget32_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_iget32_warp_nbst(shim_stream, shim_obj)


def iget32_block():
    pass
    

def _lower__Z21nvshmemx_iget32_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_iget32_block_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iget32_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmemx_iget32_block_nbst = declare_device(
        '_Z21nvshmemx_iget32_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_iget32_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z21nvshmemx_iget32_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iget32_block, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_iget32_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_iget32_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_iget32_block_nbst(shim_stream, shim_obj)


def iget64_warp():
    pass
    

def _lower__Z20nvshmemx_iget64_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_iget64_warp_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iget64_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z20nvshmemx_iget64_warp_nbst = declare_device(
        '_Z20nvshmemx_iget64_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_iget64_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z20nvshmemx_iget64_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iget64_warp, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_iget64_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_iget64_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_iget64_warp_nbst(shim_stream, shim_obj)


def iget64_block():
    pass
    

def _lower__Z21nvshmemx_iget64_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_iget64_block_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iget64_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmemx_iget64_block_nbst = declare_device(
        '_Z21nvshmemx_iget64_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_iget64_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z21nvshmemx_iget64_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iget64_block, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_iget64_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_iget64_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_iget64_block_nbst(shim_stream, shim_obj)


def iget128_warp():
    pass
    

def _lower__Z21nvshmemx_iget128_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_iget128_warp_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iget128_warp(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z21nvshmemx_iget128_warp_nbst = declare_device(
        '_Z21nvshmemx_iget128_warp_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_iget128_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z21nvshmemx_iget128_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iget128_warp, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_iget128_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_iget128_warp_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_iget128_warp_nbst(shim_stream, shim_obj)


def iget128_block():
    pass
    

def _lower__Z22nvshmemx_iget128_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_iget128_block_nbst(int &retval , void ** dest, void ** source, long* dst, long* sst, unsigned long* nelems, int* pe) {
        nvshmemx_iget128_block(*dest, *source, *dst, *sst, *nelems, *pe);
        return 0;
    }
        """


    _Z22nvshmemx_iget128_block_nbst = declare_device(
        '_Z22nvshmemx_iget128_block_nbst',
        void(
            CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_iget128_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        return _Z22nvshmemx_iget128_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5)
    

    @lower(iget128_block, CPointer(void), CPointer(void), int64, int64, uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_iget128_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_iget128_block_nbst_caller,
            signature(void, CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(int64), CPointer(int64), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_iget128_block_nbst(shim_stream, shim_obj)


def qp_bfloat16_get():
    pass
    

def _lower__Z24nvshmemx_qp_bfloat16_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_qp_bfloat16_get_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_bfloat16_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z24nvshmemx_qp_bfloat16_get_nbst = declare_device(
        '_Z24nvshmemx_qp_bfloat16_get_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_qp_bfloat16_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmemx_qp_bfloat16_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_bfloat16_get, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_qp_bfloat16_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_qp_bfloat16_get_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_qp_bfloat16_get_nbst(shim_stream, shim_obj)


def qp_bfloat16_get_warp():
    pass
    

def _lower__Z29nvshmemx_qp_bfloat16_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_bfloat16_get_warp_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_bfloat16_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_bfloat16_get_warp_nbst = declare_device(
        '_Z29nvshmemx_qp_bfloat16_get_warp_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_bfloat16_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_bfloat16_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_bfloat16_get_warp, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_bfloat16_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_bfloat16_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_bfloat16_get_warp_nbst(shim_stream, shim_obj)


def qp_bfloat16_get_block():
    pass
    

def _lower__Z30nvshmemx_qp_bfloat16_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_bfloat16_get_block_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_bfloat16_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_bfloat16_get_block_nbst = declare_device(
        '_Z30nvshmemx_qp_bfloat16_get_block_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_bfloat16_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_bfloat16_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_bfloat16_get_block, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_bfloat16_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_bfloat16_get_block_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_bfloat16_get_block_nbst(shim_stream, shim_obj)


def qp_half_get():
    pass
    

def _lower__Z20nvshmemx_qp_half_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_half_get_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_half_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_half_get_nbst = declare_device(
        '_Z20nvshmemx_qp_half_get_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_half_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z20nvshmemx_qp_half_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_half_get, CPointer(float16), CPointer(float16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_half_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_half_get_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_half_get_nbst(shim_stream, shim_obj)


def qp_half_get_warp():
    pass
    

def _lower__Z25nvshmemx_qp_half_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_half_get_warp_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_half_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_half_get_warp_nbst = declare_device(
        '_Z25nvshmemx_qp_half_get_warp_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_half_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_half_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_half_get_warp, CPointer(float16), CPointer(float16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_half_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_half_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_half_get_warp_nbst(shim_stream, shim_obj)


def qp_half_get_block():
    pass
    

def _lower__Z26nvshmemx_qp_half_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_half_get_block_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_half_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_half_get_block_nbst = declare_device(
        '_Z26nvshmemx_qp_half_get_block_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_half_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_half_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_half_get_block, CPointer(float16), CPointer(float16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_half_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_half_get_block_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_half_get_block_nbst(shim_stream, shim_obj)


def qp_float_get():
    pass
    

def _lower__Z21nvshmemx_qp_float_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_float_get_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_float_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_float_get_nbst = declare_device(
        '_Z21nvshmemx_qp_float_get_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_float_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmemx_qp_float_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_float_get, CPointer(float32), CPointer(float32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_float_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_float_get_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_float_get_nbst(shim_stream, shim_obj)


def qp_float_get_warp():
    pass
    

def _lower__Z26nvshmemx_qp_float_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_float_get_warp_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_float_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_float_get_warp_nbst = declare_device(
        '_Z26nvshmemx_qp_float_get_warp_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_float_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_float_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_float_get_warp, CPointer(float32), CPointer(float32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_float_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_float_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_float_get_warp_nbst(shim_stream, shim_obj)


def qp_float_get_block():
    pass
    

def _lower__Z27nvshmemx_qp_float_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_float_get_block_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_float_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_float_get_block_nbst = declare_device(
        '_Z27nvshmemx_qp_float_get_block_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_float_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_float_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_float_get_block, CPointer(float32), CPointer(float32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_float_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_float_get_block_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_float_get_block_nbst(shim_stream, shim_obj)


def qp_double_get():
    pass
    

def _lower__Z22nvshmemx_qp_double_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_qp_double_get_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_double_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z22nvshmemx_qp_double_get_nbst = declare_device(
        '_Z22nvshmemx_qp_double_get_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_qp_double_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z22nvshmemx_qp_double_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_double_get, CPointer(float64), CPointer(float64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_qp_double_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_qp_double_get_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_qp_double_get_nbst(shim_stream, shim_obj)


def qp_double_get_warp():
    pass
    

def _lower__Z27nvshmemx_qp_double_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_double_get_warp_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_double_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_double_get_warp_nbst = declare_device(
        '_Z27nvshmemx_qp_double_get_warp_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_double_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_double_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_double_get_warp, CPointer(float64), CPointer(float64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_double_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_double_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_double_get_warp_nbst(shim_stream, shim_obj)


def qp_double_get_block():
    pass
    

def _lower__Z28nvshmemx_qp_double_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_double_get_block_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_double_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_double_get_block_nbst = declare_device(
        '_Z28nvshmemx_qp_double_get_block_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_double_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmemx_qp_double_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_double_get_block, CPointer(float64), CPointer(float64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_double_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_double_get_block_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_double_get_block_nbst(shim_stream, shim_obj)


def qp_char_get():
    pass
    

def _lower__Z20nvshmemx_qp_char_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_char_get_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_char_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_char_get_nbst = declare_device(
        '_Z20nvshmemx_qp_char_get_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_char_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z20nvshmemx_qp_char_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_char_get, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_char_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_char_get_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_char_get_nbst(shim_stream, shim_obj)


def qp_char_get_warp():
    pass
    

def _lower__Z25nvshmemx_qp_char_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_char_get_warp_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_char_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_char_get_warp_nbst = declare_device(
        '_Z25nvshmemx_qp_char_get_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_char_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_char_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_char_get_warp, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_char_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_char_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_char_get_warp_nbst(shim_stream, shim_obj)


def qp_char_get_block():
    pass
    

def _lower__Z26nvshmemx_qp_char_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_char_get_block_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_char_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_char_get_block_nbst = declare_device(
        '_Z26nvshmemx_qp_char_get_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_char_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_char_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_char_get_block, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_char_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_char_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_char_get_block_nbst(shim_stream, shim_obj)


def qp_short_get():
    pass
    

def _lower__Z21nvshmemx_qp_short_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_short_get_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_short_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_short_get_nbst = declare_device(
        '_Z21nvshmemx_qp_short_get_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_short_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmemx_qp_short_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_short_get, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_short_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_short_get_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_short_get_nbst(shim_stream, shim_obj)


def qp_short_get_warp():
    pass
    

def _lower__Z26nvshmemx_qp_short_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_short_get_warp_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_short_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_short_get_warp_nbst = declare_device(
        '_Z26nvshmemx_qp_short_get_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_short_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_short_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_short_get_warp, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_short_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_short_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_short_get_warp_nbst(shim_stream, shim_obj)


def qp_short_get_block():
    pass
    

def _lower__Z27nvshmemx_qp_short_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_short_get_block_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_short_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_short_get_block_nbst = declare_device(
        '_Z27nvshmemx_qp_short_get_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_short_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_short_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_short_get_block, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_short_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_short_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_short_get_block_nbst(shim_stream, shim_obj)


def qp_schar_get():
    pass
    

def _lower__Z21nvshmemx_qp_schar_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_schar_get_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_schar_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_schar_get_nbst = declare_device(
        '_Z21nvshmemx_qp_schar_get_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_schar_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmemx_qp_schar_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_schar_get, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_schar_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_schar_get_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_schar_get_nbst(shim_stream, shim_obj)


def qp_schar_get_warp():
    pass
    

def _lower__Z26nvshmemx_qp_schar_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_schar_get_warp_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_schar_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_schar_get_warp_nbst = declare_device(
        '_Z26nvshmemx_qp_schar_get_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_schar_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_schar_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_schar_get_warp, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_schar_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_schar_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_schar_get_warp_nbst(shim_stream, shim_obj)


def qp_schar_get_block():
    pass
    

def _lower__Z27nvshmemx_qp_schar_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_schar_get_block_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_schar_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_schar_get_block_nbst = declare_device(
        '_Z27nvshmemx_qp_schar_get_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_schar_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_schar_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_schar_get_block, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_schar_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_schar_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_schar_get_block_nbst(shim_stream, shim_obj)


def qp_int_get():
    pass
    

def _lower__Z19nvshmemx_qp_int_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_int_get_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_int_get_nbst = declare_device(
        '_Z19nvshmemx_qp_int_get_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_int_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z19nvshmemx_qp_int_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int_get, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_int_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_int_get_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_int_get_nbst(shim_stream, shim_obj)


def qp_int_get_warp():
    pass
    

def _lower__Z24nvshmemx_qp_int_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_qp_int_get_warp_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z24nvshmemx_qp_int_get_warp_nbst = declare_device(
        '_Z24nvshmemx_qp_int_get_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_qp_int_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmemx_qp_int_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int_get_warp, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_qp_int_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_qp_int_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_qp_int_get_warp_nbst(shim_stream, shim_obj)


def qp_int_get_block():
    pass
    

def _lower__Z25nvshmemx_qp_int_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_int_get_block_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_int_get_block_nbst = declare_device(
        '_Z25nvshmemx_qp_int_get_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_int_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_int_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int_get_block, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_int_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_int_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_int_get_block_nbst(shim_stream, shim_obj)


def qp_long_get():
    pass
    

def _lower__Z20nvshmemx_qp_long_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_long_get_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_long_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_long_get_nbst = declare_device(
        '_Z20nvshmemx_qp_long_get_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_long_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z20nvshmemx_qp_long_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_long_get, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_long_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_long_get_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_long_get_nbst(shim_stream, shim_obj)


def qp_long_get_warp():
    pass
    

def _lower__Z25nvshmemx_qp_long_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_long_get_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_long_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_long_get_warp_nbst = declare_device(
        '_Z25nvshmemx_qp_long_get_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_long_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_long_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_long_get_warp, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_long_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_long_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_long_get_warp_nbst(shim_stream, shim_obj)


def qp_long_get_block():
    pass
    

def _lower__Z26nvshmemx_qp_long_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_long_get_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_long_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_long_get_block_nbst = declare_device(
        '_Z26nvshmemx_qp_long_get_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_long_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_long_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_long_get_block, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_long_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_long_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_long_get_block_nbst(shim_stream, shim_obj)


def qp_longlong_get():
    pass
    

def _lower__Z24nvshmemx_qp_longlong_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_qp_longlong_get_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_longlong_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z24nvshmemx_qp_longlong_get_nbst = declare_device(
        '_Z24nvshmemx_qp_longlong_get_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_qp_longlong_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmemx_qp_longlong_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_longlong_get, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_qp_longlong_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_qp_longlong_get_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_qp_longlong_get_nbst(shim_stream, shim_obj)


def qp_longlong_get_warp():
    pass
    

def _lower__Z29nvshmemx_qp_longlong_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_longlong_get_warp_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_longlong_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_longlong_get_warp_nbst = declare_device(
        '_Z29nvshmemx_qp_longlong_get_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_longlong_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_longlong_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_longlong_get_warp, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_longlong_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_longlong_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_longlong_get_warp_nbst(shim_stream, shim_obj)


def qp_longlong_get_block():
    pass
    

def _lower__Z30nvshmemx_qp_longlong_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_longlong_get_block_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_longlong_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_longlong_get_block_nbst = declare_device(
        '_Z30nvshmemx_qp_longlong_get_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_longlong_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_longlong_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_longlong_get_block, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_longlong_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_longlong_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_longlong_get_block_nbst(shim_stream, shim_obj)


def qp_uchar_get():
    pass
    

def _lower__Z21nvshmemx_qp_uchar_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_uchar_get_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uchar_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_uchar_get_nbst = declare_device(
        '_Z21nvshmemx_qp_uchar_get_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_uchar_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmemx_qp_uchar_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uchar_get, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_uchar_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_uchar_get_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_uchar_get_nbst(shim_stream, shim_obj)


def qp_uchar_get_warp():
    pass
    

def _lower__Z26nvshmemx_qp_uchar_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_uchar_get_warp_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uchar_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_uchar_get_warp_nbst = declare_device(
        '_Z26nvshmemx_qp_uchar_get_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_uchar_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_uchar_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uchar_get_warp, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_uchar_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_uchar_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_uchar_get_warp_nbst(shim_stream, shim_obj)


def qp_uchar_get_block():
    pass
    

def _lower__Z27nvshmemx_qp_uchar_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_uchar_get_block_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uchar_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_uchar_get_block_nbst = declare_device(
        '_Z27nvshmemx_qp_uchar_get_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_uchar_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_uchar_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uchar_get_block, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_uchar_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_uchar_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_uchar_get_block_nbst(shim_stream, shim_obj)


def qp_ushort_get():
    pass
    

def _lower__Z22nvshmemx_qp_ushort_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_qp_ushort_get_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ushort_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z22nvshmemx_qp_ushort_get_nbst = declare_device(
        '_Z22nvshmemx_qp_ushort_get_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_qp_ushort_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z22nvshmemx_qp_ushort_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ushort_get, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_qp_ushort_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_qp_ushort_get_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_qp_ushort_get_nbst(shim_stream, shim_obj)


def qp_ushort_get_warp():
    pass
    

def _lower__Z27nvshmemx_qp_ushort_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_ushort_get_warp_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ushort_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_ushort_get_warp_nbst = declare_device(
        '_Z27nvshmemx_qp_ushort_get_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_ushort_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_ushort_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ushort_get_warp, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_ushort_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_ushort_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_ushort_get_warp_nbst(shim_stream, shim_obj)


def qp_ushort_get_block():
    pass
    

def _lower__Z28nvshmemx_qp_ushort_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_ushort_get_block_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ushort_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_ushort_get_block_nbst = declare_device(
        '_Z28nvshmemx_qp_ushort_get_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_ushort_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmemx_qp_ushort_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ushort_get_block, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_ushort_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_ushort_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_ushort_get_block_nbst(shim_stream, shim_obj)


def qp_uint_get():
    pass
    

def _lower__Z20nvshmemx_qp_uint_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_uint_get_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_uint_get_nbst = declare_device(
        '_Z20nvshmemx_qp_uint_get_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_uint_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z20nvshmemx_qp_uint_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint_get, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_uint_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_uint_get_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_uint_get_nbst(shim_stream, shim_obj)


def qp_uint_get_warp():
    pass
    

def _lower__Z25nvshmemx_qp_uint_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_uint_get_warp_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_uint_get_warp_nbst = declare_device(
        '_Z25nvshmemx_qp_uint_get_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_uint_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_uint_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint_get_warp, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_uint_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_uint_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_uint_get_warp_nbst(shim_stream, shim_obj)


def qp_uint_get_block():
    pass
    

def _lower__Z26nvshmemx_qp_uint_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_uint_get_block_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_uint_get_block_nbst = declare_device(
        '_Z26nvshmemx_qp_uint_get_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_uint_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_uint_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint_get_block, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_uint_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_uint_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_uint_get_block_nbst(shim_stream, shim_obj)


def qp_ulong_get():
    pass
    

def _lower__Z21nvshmemx_qp_ulong_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_ulong_get_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulong_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_ulong_get_nbst = declare_device(
        '_Z21nvshmemx_qp_ulong_get_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_ulong_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmemx_qp_ulong_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulong_get, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_ulong_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_ulong_get_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_ulong_get_nbst(shim_stream, shim_obj)


def qp_ulong_get_warp():
    pass
    

def _lower__Z26nvshmemx_qp_ulong_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_ulong_get_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulong_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_ulong_get_warp_nbst = declare_device(
        '_Z26nvshmemx_qp_ulong_get_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_ulong_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_ulong_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulong_get_warp, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_ulong_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_ulong_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_ulong_get_warp_nbst(shim_stream, shim_obj)


def qp_ulong_get_block():
    pass
    

def _lower__Z27nvshmemx_qp_ulong_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_ulong_get_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulong_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_ulong_get_block_nbst = declare_device(
        '_Z27nvshmemx_qp_ulong_get_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_ulong_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_ulong_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulong_get_block, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_ulong_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_ulong_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_ulong_get_block_nbst(shim_stream, shim_obj)


def qp_ulonglong_get():
    pass
    

def _lower__Z25nvshmemx_qp_ulonglong_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_ulonglong_get_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulonglong_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_ulonglong_get_nbst = declare_device(
        '_Z25nvshmemx_qp_ulonglong_get_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_ulonglong_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_ulonglong_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulonglong_get, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_ulonglong_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_ulonglong_get_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_ulonglong_get_nbst(shim_stream, shim_obj)


def qp_ulonglong_get_warp():
    pass
    

def _lower__Z30nvshmemx_qp_ulonglong_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_ulonglong_get_warp_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulonglong_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_ulonglong_get_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_ulonglong_get_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_ulonglong_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_ulonglong_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulonglong_get_warp, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_ulonglong_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_ulonglong_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_ulonglong_get_warp_nbst(shim_stream, shim_obj)


def qp_ulonglong_get_block():
    pass
    

def _lower__Z31nvshmemx_qp_ulonglong_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_ulonglong_get_block_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulonglong_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_ulonglong_get_block_nbst = declare_device(
        '_Z31nvshmemx_qp_ulonglong_get_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_ulonglong_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_ulonglong_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulonglong_get_block, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_ulonglong_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_ulonglong_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_ulonglong_get_block_nbst(shim_stream, shim_obj)


def qp_int8_get():
    pass
    

def _lower__Z20nvshmemx_qp_int8_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_int8_get_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int8_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_int8_get_nbst = declare_device(
        '_Z20nvshmemx_qp_int8_get_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_int8_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z20nvshmemx_qp_int8_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int8_get, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_int8_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_int8_get_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_int8_get_nbst(shim_stream, shim_obj)


def qp_int8_get_warp():
    pass
    

def _lower__Z25nvshmemx_qp_int8_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_int8_get_warp_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int8_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_int8_get_warp_nbst = declare_device(
        '_Z25nvshmemx_qp_int8_get_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_int8_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_int8_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int8_get_warp, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_int8_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_int8_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_int8_get_warp_nbst(shim_stream, shim_obj)


def qp_int8_get_block():
    pass
    

def _lower__Z26nvshmemx_qp_int8_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_int8_get_block_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int8_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_int8_get_block_nbst = declare_device(
        '_Z26nvshmemx_qp_int8_get_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_int8_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_int8_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int8_get_block, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_int8_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_int8_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_int8_get_block_nbst(shim_stream, shim_obj)


def qp_int16_get():
    pass
    

def _lower__Z21nvshmemx_qp_int16_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_int16_get_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int16_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_int16_get_nbst = declare_device(
        '_Z21nvshmemx_qp_int16_get_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_int16_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmemx_qp_int16_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int16_get, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_int16_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_int16_get_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_int16_get_nbst(shim_stream, shim_obj)


def qp_int16_get_warp():
    pass
    

def _lower__Z26nvshmemx_qp_int16_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_int16_get_warp_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int16_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_int16_get_warp_nbst = declare_device(
        '_Z26nvshmemx_qp_int16_get_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_int16_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_int16_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int16_get_warp, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_int16_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_int16_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_int16_get_warp_nbst(shim_stream, shim_obj)


def qp_int16_get_block():
    pass
    

def _lower__Z27nvshmemx_qp_int16_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_int16_get_block_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int16_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_int16_get_block_nbst = declare_device(
        '_Z27nvshmemx_qp_int16_get_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_int16_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_int16_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int16_get_block, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_int16_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_int16_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_int16_get_block_nbst(shim_stream, shim_obj)


def qp_int32_get():
    pass
    

def _lower__Z21nvshmemx_qp_int32_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_int32_get_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int32_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_int32_get_nbst = declare_device(
        '_Z21nvshmemx_qp_int32_get_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_int32_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmemx_qp_int32_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int32_get, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_int32_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_int32_get_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_int32_get_nbst(shim_stream, shim_obj)


def qp_int32_get_warp():
    pass
    

def _lower__Z26nvshmemx_qp_int32_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_int32_get_warp_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int32_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_int32_get_warp_nbst = declare_device(
        '_Z26nvshmemx_qp_int32_get_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_int32_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_int32_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int32_get_warp, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_int32_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_int32_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_int32_get_warp_nbst(shim_stream, shim_obj)


def qp_int32_get_block():
    pass
    

def _lower__Z27nvshmemx_qp_int32_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_int32_get_block_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int32_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_int32_get_block_nbst = declare_device(
        '_Z27nvshmemx_qp_int32_get_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_int32_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_int32_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int32_get_block, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_int32_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_int32_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_int32_get_block_nbst(shim_stream, shim_obj)


def qp_int64_get():
    pass
    

def _lower__Z21nvshmemx_qp_int64_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_int64_get_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int64_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_int64_get_nbst = declare_device(
        '_Z21nvshmemx_qp_int64_get_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_int64_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmemx_qp_int64_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int64_get, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_int64_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_int64_get_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_int64_get_nbst(shim_stream, shim_obj)


def qp_int64_get_warp():
    pass
    

def _lower__Z26nvshmemx_qp_int64_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_int64_get_warp_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int64_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_int64_get_warp_nbst = declare_device(
        '_Z26nvshmemx_qp_int64_get_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_int64_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_int64_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int64_get_warp, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_int64_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_int64_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_int64_get_warp_nbst(shim_stream, shim_obj)


def qp_int64_get_block():
    pass
    

def _lower__Z27nvshmemx_qp_int64_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_int64_get_block_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int64_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_int64_get_block_nbst = declare_device(
        '_Z27nvshmemx_qp_int64_get_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_int64_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_int64_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int64_get_block, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_int64_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_int64_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_int64_get_block_nbst(shim_stream, shim_obj)


def qp_uint8_get():
    pass
    

def _lower__Z21nvshmemx_qp_uint8_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_uint8_get_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint8_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_uint8_get_nbst = declare_device(
        '_Z21nvshmemx_qp_uint8_get_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_uint8_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmemx_qp_uint8_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint8_get, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_uint8_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_uint8_get_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_uint8_get_nbst(shim_stream, shim_obj)


def qp_uint8_get_warp():
    pass
    

def _lower__Z26nvshmemx_qp_uint8_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_uint8_get_warp_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint8_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_uint8_get_warp_nbst = declare_device(
        '_Z26nvshmemx_qp_uint8_get_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_uint8_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_uint8_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint8_get_warp, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_uint8_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_uint8_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_uint8_get_warp_nbst(shim_stream, shim_obj)


def qp_uint8_get_block():
    pass
    

def _lower__Z27nvshmemx_qp_uint8_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_uint8_get_block_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint8_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_uint8_get_block_nbst = declare_device(
        '_Z27nvshmemx_qp_uint8_get_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_uint8_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_uint8_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint8_get_block, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_uint8_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_uint8_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_uint8_get_block_nbst(shim_stream, shim_obj)


def qp_uint16_get():
    pass
    

def _lower__Z22nvshmemx_qp_uint16_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_qp_uint16_get_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint16_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z22nvshmemx_qp_uint16_get_nbst = declare_device(
        '_Z22nvshmemx_qp_uint16_get_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_qp_uint16_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z22nvshmemx_qp_uint16_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint16_get, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_qp_uint16_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_qp_uint16_get_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_qp_uint16_get_nbst(shim_stream, shim_obj)


def qp_uint16_get_warp():
    pass
    

def _lower__Z27nvshmemx_qp_uint16_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_uint16_get_warp_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint16_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_uint16_get_warp_nbst = declare_device(
        '_Z27nvshmemx_qp_uint16_get_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_uint16_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_uint16_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint16_get_warp, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_uint16_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_uint16_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_uint16_get_warp_nbst(shim_stream, shim_obj)


def qp_uint16_get_block():
    pass
    

def _lower__Z28nvshmemx_qp_uint16_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_uint16_get_block_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint16_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_uint16_get_block_nbst = declare_device(
        '_Z28nvshmemx_qp_uint16_get_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_uint16_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmemx_qp_uint16_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint16_get_block, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_uint16_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_uint16_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_uint16_get_block_nbst(shim_stream, shim_obj)


def qp_uint32_get():
    pass
    

def _lower__Z22nvshmemx_qp_uint32_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_qp_uint32_get_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint32_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z22nvshmemx_qp_uint32_get_nbst = declare_device(
        '_Z22nvshmemx_qp_uint32_get_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_qp_uint32_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z22nvshmemx_qp_uint32_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint32_get, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_qp_uint32_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_qp_uint32_get_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_qp_uint32_get_nbst(shim_stream, shim_obj)


def qp_uint32_get_warp():
    pass
    

def _lower__Z27nvshmemx_qp_uint32_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_uint32_get_warp_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint32_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_uint32_get_warp_nbst = declare_device(
        '_Z27nvshmemx_qp_uint32_get_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_uint32_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_uint32_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint32_get_warp, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_uint32_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_uint32_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_uint32_get_warp_nbst(shim_stream, shim_obj)


def qp_uint32_get_block():
    pass
    

def _lower__Z28nvshmemx_qp_uint32_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_uint32_get_block_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint32_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_uint32_get_block_nbst = declare_device(
        '_Z28nvshmemx_qp_uint32_get_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_uint32_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmemx_qp_uint32_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint32_get_block, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_uint32_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_uint32_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_uint32_get_block_nbst(shim_stream, shim_obj)


def qp_uint64_get():
    pass
    

def _lower__Z22nvshmemx_qp_uint64_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_qp_uint64_get_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint64_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z22nvshmemx_qp_uint64_get_nbst = declare_device(
        '_Z22nvshmemx_qp_uint64_get_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_qp_uint64_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z22nvshmemx_qp_uint64_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint64_get, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_qp_uint64_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_qp_uint64_get_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_qp_uint64_get_nbst(shim_stream, shim_obj)


def qp_uint64_get_warp():
    pass
    

def _lower__Z27nvshmemx_qp_uint64_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_uint64_get_warp_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint64_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_uint64_get_warp_nbst = declare_device(
        '_Z27nvshmemx_qp_uint64_get_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_uint64_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_uint64_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint64_get_warp, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_uint64_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_uint64_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_uint64_get_warp_nbst(shim_stream, shim_obj)


def qp_uint64_get_block():
    pass
    

def _lower__Z28nvshmemx_qp_uint64_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_uint64_get_block_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint64_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_uint64_get_block_nbst = declare_device(
        '_Z28nvshmemx_qp_uint64_get_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_uint64_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmemx_qp_uint64_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint64_get_block, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_uint64_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_uint64_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_uint64_get_block_nbst(shim_stream, shim_obj)


def qp_size_get():
    pass
    

def _lower__Z20nvshmemx_qp_size_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_size_get_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_size_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_size_get_nbst = declare_device(
        '_Z20nvshmemx_qp_size_get_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_size_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z20nvshmemx_qp_size_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_size_get, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_size_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_size_get_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_size_get_nbst(shim_stream, shim_obj)


def qp_size_get_warp():
    pass
    

def _lower__Z25nvshmemx_qp_size_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_size_get_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_size_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_size_get_warp_nbst = declare_device(
        '_Z25nvshmemx_qp_size_get_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_size_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_size_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_size_get_warp, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_size_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_size_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_size_get_warp_nbst(shim_stream, shim_obj)


def qp_size_get_block():
    pass
    

def _lower__Z26nvshmemx_qp_size_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_size_get_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_size_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_size_get_block_nbst = declare_device(
        '_Z26nvshmemx_qp_size_get_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_size_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_size_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_size_get_block, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_size_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_size_get_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_size_get_block_nbst(shim_stream, shim_obj)


def qp_ptrdiff_get():
    pass
    

def _lower__Z23nvshmemx_qp_ptrdiff_get_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_qp_ptrdiff_get_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ptrdiff_get(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z23nvshmemx_qp_ptrdiff_get_nbst = declare_device(
        '_Z23nvshmemx_qp_ptrdiff_get_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_qp_ptrdiff_get_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z23nvshmemx_qp_ptrdiff_get_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ptrdiff_get, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_qp_ptrdiff_get_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_qp_ptrdiff_get_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_qp_ptrdiff_get_nbst(shim_stream, shim_obj)


def qp_ptrdiff_get_warp():
    pass
    

def _lower__Z28nvshmemx_qp_ptrdiff_get_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_ptrdiff_get_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ptrdiff_get_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_ptrdiff_get_warp_nbst = declare_device(
        '_Z28nvshmemx_qp_ptrdiff_get_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_ptrdiff_get_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmemx_qp_ptrdiff_get_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ptrdiff_get_warp, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_ptrdiff_get_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_ptrdiff_get_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_ptrdiff_get_warp_nbst(shim_stream, shim_obj)


def qp_ptrdiff_get_block():
    pass
    

def _lower__Z29nvshmemx_qp_ptrdiff_get_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_ptrdiff_get_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ptrdiff_get_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_ptrdiff_get_block_nbst = declare_device(
        '_Z29nvshmemx_qp_ptrdiff_get_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_ptrdiff_get_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_ptrdiff_get_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ptrdiff_get_block, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_ptrdiff_get_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_ptrdiff_get_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_ptrdiff_get_block_nbst(shim_stream, shim_obj)


def qp_bfloat16_get_nbi():
    pass
    

def _lower__Z28nvshmemx_qp_bfloat16_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_bfloat16_get_nbi_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_bfloat16_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_bfloat16_get_nbi_nbst = declare_device(
        '_Z28nvshmemx_qp_bfloat16_get_nbi_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_bfloat16_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmemx_qp_bfloat16_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_bfloat16_get_nbi, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_bfloat16_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_bfloat16_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_bfloat16_get_nbi_nbst(shim_stream, shim_obj)


def qp_bfloat16_get_nbi_warp():
    pass
    

def _lower__Z33nvshmemx_qp_bfloat16_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_bfloat16_get_nbi_warp_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_bfloat16_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_bfloat16_get_nbi_warp_nbst = declare_device(
        '_Z33nvshmemx_qp_bfloat16_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_bfloat16_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z33nvshmemx_qp_bfloat16_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_bfloat16_get_nbi_warp, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_bfloat16_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_bfloat16_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_bfloat16_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_bfloat16_get_nbi_block():
    pass
    

def _lower__Z34nvshmemx_qp_bfloat16_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_bfloat16_get_nbi_block_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_bfloat16_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_bfloat16_get_nbi_block_nbst = declare_device(
        '_Z34nvshmemx_qp_bfloat16_get_nbi_block_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_bfloat16_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z34nvshmemx_qp_bfloat16_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_bfloat16_get_nbi_block, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_bfloat16_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_bfloat16_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_bfloat16_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_half_get_nbi():
    pass
    

def _lower__Z24nvshmemx_qp_half_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_qp_half_get_nbi_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_half_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z24nvshmemx_qp_half_get_nbi_nbst = declare_device(
        '_Z24nvshmemx_qp_half_get_nbi_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_qp_half_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmemx_qp_half_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_half_get_nbi, CPointer(float16), CPointer(float16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_qp_half_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_qp_half_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_qp_half_get_nbi_nbst(shim_stream, shim_obj)


def qp_half_get_nbi_warp():
    pass
    

def _lower__Z29nvshmemx_qp_half_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_half_get_nbi_warp_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_half_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_half_get_nbi_warp_nbst = declare_device(
        '_Z29nvshmemx_qp_half_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_half_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_half_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_half_get_nbi_warp, CPointer(float16), CPointer(float16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_half_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_half_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_half_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_half_get_nbi_block():
    pass
    

def _lower__Z30nvshmemx_qp_half_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_half_get_nbi_block_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_half_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_half_get_nbi_block_nbst = declare_device(
        '_Z30nvshmemx_qp_half_get_nbi_block_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_half_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_half_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_half_get_nbi_block, CPointer(float16), CPointer(float16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_half_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_half_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_half_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_float_get_nbi():
    pass
    

def _lower__Z25nvshmemx_qp_float_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_float_get_nbi_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_float_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_float_get_nbi_nbst = declare_device(
        '_Z25nvshmemx_qp_float_get_nbi_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_float_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_float_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_float_get_nbi, CPointer(float32), CPointer(float32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_float_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_float_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_float_get_nbi_nbst(shim_stream, shim_obj)


def qp_float_get_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_qp_float_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_float_get_nbi_warp_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_float_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_float_get_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_float_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_float_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_float_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_float_get_nbi_warp, CPointer(float32), CPointer(float32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_float_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_float_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_float_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_float_get_nbi_block():
    pass
    

def _lower__Z31nvshmemx_qp_float_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_float_get_nbi_block_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_float_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_float_get_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_qp_float_get_nbi_block_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_float_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_float_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_float_get_nbi_block, CPointer(float32), CPointer(float32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_float_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_float_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_float_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_double_get_nbi():
    pass
    

def _lower__Z26nvshmemx_qp_double_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_double_get_nbi_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_double_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_double_get_nbi_nbst = declare_device(
        '_Z26nvshmemx_qp_double_get_nbi_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_double_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_double_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_double_get_nbi, CPointer(float64), CPointer(float64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_double_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_double_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_double_get_nbi_nbst(shim_stream, shim_obj)


def qp_double_get_nbi_warp():
    pass
    

def _lower__Z31nvshmemx_qp_double_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_double_get_nbi_warp_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_double_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_double_get_nbi_warp_nbst = declare_device(
        '_Z31nvshmemx_qp_double_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_double_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_double_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_double_get_nbi_warp, CPointer(float64), CPointer(float64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_double_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_double_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_double_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_double_get_nbi_block():
    pass
    

def _lower__Z32nvshmemx_qp_double_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_double_get_nbi_block_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_double_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_double_get_nbi_block_nbst = declare_device(
        '_Z32nvshmemx_qp_double_get_nbi_block_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_double_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z32nvshmemx_qp_double_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_double_get_nbi_block, CPointer(float64), CPointer(float64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_double_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_double_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_double_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_char_get_nbi():
    pass
    

def _lower__Z24nvshmemx_qp_char_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_qp_char_get_nbi_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_char_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z24nvshmemx_qp_char_get_nbi_nbst = declare_device(
        '_Z24nvshmemx_qp_char_get_nbi_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_qp_char_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmemx_qp_char_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_char_get_nbi, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_qp_char_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_qp_char_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_qp_char_get_nbi_nbst(shim_stream, shim_obj)


def qp_char_get_nbi_warp():
    pass
    

def _lower__Z29nvshmemx_qp_char_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_char_get_nbi_warp_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_char_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_char_get_nbi_warp_nbst = declare_device(
        '_Z29nvshmemx_qp_char_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_char_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_char_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_char_get_nbi_warp, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_char_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_char_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_char_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_char_get_nbi_block():
    pass
    

def _lower__Z30nvshmemx_qp_char_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_char_get_nbi_block_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_char_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_char_get_nbi_block_nbst = declare_device(
        '_Z30nvshmemx_qp_char_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_char_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_char_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_char_get_nbi_block, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_char_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_char_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_char_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_short_get_nbi():
    pass
    

def _lower__Z25nvshmemx_qp_short_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_short_get_nbi_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_short_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_short_get_nbi_nbst = declare_device(
        '_Z25nvshmemx_qp_short_get_nbi_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_short_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_short_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_short_get_nbi, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_short_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_short_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_short_get_nbi_nbst(shim_stream, shim_obj)


def qp_short_get_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_qp_short_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_short_get_nbi_warp_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_short_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_short_get_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_short_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_short_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_short_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_short_get_nbi_warp, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_short_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_short_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_short_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_short_get_nbi_block():
    pass
    

def _lower__Z31nvshmemx_qp_short_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_short_get_nbi_block_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_short_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_short_get_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_qp_short_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_short_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_short_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_short_get_nbi_block, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_short_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_short_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_short_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_schar_get_nbi():
    pass
    

def _lower__Z25nvshmemx_qp_schar_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_schar_get_nbi_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_schar_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_schar_get_nbi_nbst = declare_device(
        '_Z25nvshmemx_qp_schar_get_nbi_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_schar_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_schar_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_schar_get_nbi, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_schar_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_schar_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_schar_get_nbi_nbst(shim_stream, shim_obj)


def qp_schar_get_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_qp_schar_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_schar_get_nbi_warp_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_schar_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_schar_get_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_schar_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_schar_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_schar_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_schar_get_nbi_warp, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_schar_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_schar_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_schar_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_schar_get_nbi_block():
    pass
    

def _lower__Z31nvshmemx_qp_schar_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_schar_get_nbi_block_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_schar_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_schar_get_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_qp_schar_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_schar_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_schar_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_schar_get_nbi_block, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_schar_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_schar_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_schar_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_int_get_nbi():
    pass
    

def _lower__Z23nvshmemx_qp_int_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_qp_int_get_nbi_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z23nvshmemx_qp_int_get_nbi_nbst = declare_device(
        '_Z23nvshmemx_qp_int_get_nbi_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_qp_int_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z23nvshmemx_qp_int_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int_get_nbi, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_qp_int_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_qp_int_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_qp_int_get_nbi_nbst(shim_stream, shim_obj)


def qp_int_get_nbi_warp():
    pass
    

def _lower__Z28nvshmemx_qp_int_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_int_get_nbi_warp_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_int_get_nbi_warp_nbst = declare_device(
        '_Z28nvshmemx_qp_int_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_int_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmemx_qp_int_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int_get_nbi_warp, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_int_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_int_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_int_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_int_get_nbi_block():
    pass
    

def _lower__Z29nvshmemx_qp_int_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_int_get_nbi_block_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_int_get_nbi_block_nbst = declare_device(
        '_Z29nvshmemx_qp_int_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_int_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_int_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int_get_nbi_block, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_int_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_int_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_int_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_long_get_nbi():
    pass
    

def _lower__Z24nvshmemx_qp_long_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_qp_long_get_nbi_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_long_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z24nvshmemx_qp_long_get_nbi_nbst = declare_device(
        '_Z24nvshmemx_qp_long_get_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_qp_long_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmemx_qp_long_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_long_get_nbi, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_qp_long_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_qp_long_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_qp_long_get_nbi_nbst(shim_stream, shim_obj)


def qp_long_get_nbi_warp():
    pass
    

def _lower__Z29nvshmemx_qp_long_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_long_get_nbi_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_long_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_long_get_nbi_warp_nbst = declare_device(
        '_Z29nvshmemx_qp_long_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_long_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_long_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_long_get_nbi_warp, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_long_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_long_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_long_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_long_get_nbi_block():
    pass
    

def _lower__Z30nvshmemx_qp_long_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_long_get_nbi_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_long_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_long_get_nbi_block_nbst = declare_device(
        '_Z30nvshmemx_qp_long_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_long_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_long_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_long_get_nbi_block, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_long_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_long_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_long_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_longlong_get_nbi():
    pass
    

def _lower__Z28nvshmemx_qp_longlong_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_longlong_get_nbi_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_longlong_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_longlong_get_nbi_nbst = declare_device(
        '_Z28nvshmemx_qp_longlong_get_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_longlong_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmemx_qp_longlong_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_longlong_get_nbi, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_longlong_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_longlong_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_longlong_get_nbi_nbst(shim_stream, shim_obj)


def qp_longlong_get_nbi_warp():
    pass
    

def _lower__Z33nvshmemx_qp_longlong_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_longlong_get_nbi_warp_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_longlong_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_longlong_get_nbi_warp_nbst = declare_device(
        '_Z33nvshmemx_qp_longlong_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_longlong_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z33nvshmemx_qp_longlong_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_longlong_get_nbi_warp, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_longlong_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_longlong_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_longlong_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_longlong_get_nbi_block():
    pass
    

def _lower__Z34nvshmemx_qp_longlong_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_longlong_get_nbi_block_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_longlong_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_longlong_get_nbi_block_nbst = declare_device(
        '_Z34nvshmemx_qp_longlong_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_longlong_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z34nvshmemx_qp_longlong_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_longlong_get_nbi_block, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_longlong_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_longlong_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_longlong_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_uchar_get_nbi():
    pass
    

def _lower__Z25nvshmemx_qp_uchar_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_uchar_get_nbi_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uchar_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_uchar_get_nbi_nbst = declare_device(
        '_Z25nvshmemx_qp_uchar_get_nbi_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_uchar_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_uchar_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uchar_get_nbi, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_uchar_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_uchar_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_uchar_get_nbi_nbst(shim_stream, shim_obj)


def qp_uchar_get_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_qp_uchar_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_uchar_get_nbi_warp_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uchar_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_uchar_get_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_uchar_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_uchar_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_uchar_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uchar_get_nbi_warp, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_uchar_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_uchar_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_uchar_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_uchar_get_nbi_block():
    pass
    

def _lower__Z31nvshmemx_qp_uchar_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_uchar_get_nbi_block_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uchar_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_uchar_get_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_qp_uchar_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_uchar_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_uchar_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uchar_get_nbi_block, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_uchar_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_uchar_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_uchar_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_ushort_get_nbi():
    pass
    

def _lower__Z26nvshmemx_qp_ushort_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_ushort_get_nbi_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ushort_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_ushort_get_nbi_nbst = declare_device(
        '_Z26nvshmemx_qp_ushort_get_nbi_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_ushort_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_ushort_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ushort_get_nbi, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_ushort_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_ushort_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_ushort_get_nbi_nbst(shim_stream, shim_obj)


def qp_ushort_get_nbi_warp():
    pass
    

def _lower__Z31nvshmemx_qp_ushort_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_ushort_get_nbi_warp_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ushort_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_ushort_get_nbi_warp_nbst = declare_device(
        '_Z31nvshmemx_qp_ushort_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_ushort_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_ushort_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ushort_get_nbi_warp, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_ushort_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_ushort_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_ushort_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_ushort_get_nbi_block():
    pass
    

def _lower__Z32nvshmemx_qp_ushort_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_ushort_get_nbi_block_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ushort_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_ushort_get_nbi_block_nbst = declare_device(
        '_Z32nvshmemx_qp_ushort_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_ushort_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z32nvshmemx_qp_ushort_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ushort_get_nbi_block, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_ushort_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_ushort_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_ushort_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_uint_get_nbi():
    pass
    

def _lower__Z24nvshmemx_qp_uint_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_qp_uint_get_nbi_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z24nvshmemx_qp_uint_get_nbi_nbst = declare_device(
        '_Z24nvshmemx_qp_uint_get_nbi_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_qp_uint_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmemx_qp_uint_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint_get_nbi, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_qp_uint_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_qp_uint_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_qp_uint_get_nbi_nbst(shim_stream, shim_obj)


def qp_uint_get_nbi_warp():
    pass
    

def _lower__Z29nvshmemx_qp_uint_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_uint_get_nbi_warp_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_uint_get_nbi_warp_nbst = declare_device(
        '_Z29nvshmemx_qp_uint_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_uint_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_uint_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint_get_nbi_warp, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_uint_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_uint_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_uint_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_uint_get_nbi_block():
    pass
    

def _lower__Z30nvshmemx_qp_uint_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_uint_get_nbi_block_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_uint_get_nbi_block_nbst = declare_device(
        '_Z30nvshmemx_qp_uint_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_uint_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_uint_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint_get_nbi_block, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_uint_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_uint_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_uint_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_ulong_get_nbi():
    pass
    

def _lower__Z25nvshmemx_qp_ulong_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_ulong_get_nbi_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulong_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_ulong_get_nbi_nbst = declare_device(
        '_Z25nvshmemx_qp_ulong_get_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_ulong_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_ulong_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulong_get_nbi, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_ulong_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_ulong_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_ulong_get_nbi_nbst(shim_stream, shim_obj)


def qp_ulong_get_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_qp_ulong_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_ulong_get_nbi_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulong_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_ulong_get_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_ulong_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_ulong_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_ulong_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulong_get_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_ulong_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_ulong_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_ulong_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_ulong_get_nbi_block():
    pass
    

def _lower__Z31nvshmemx_qp_ulong_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_ulong_get_nbi_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulong_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_ulong_get_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_qp_ulong_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_ulong_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_ulong_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulong_get_nbi_block, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_ulong_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_ulong_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_ulong_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_ulonglong_get_nbi():
    pass
    

def _lower__Z29nvshmemx_qp_ulonglong_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_ulonglong_get_nbi_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulonglong_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_ulonglong_get_nbi_nbst = declare_device(
        '_Z29nvshmemx_qp_ulonglong_get_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_ulonglong_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_ulonglong_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulonglong_get_nbi, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_ulonglong_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_ulonglong_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_ulonglong_get_nbi_nbst(shim_stream, shim_obj)


def qp_ulonglong_get_nbi_warp():
    pass
    

def _lower__Z34nvshmemx_qp_ulonglong_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_ulonglong_get_nbi_warp_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulonglong_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_ulonglong_get_nbi_warp_nbst = declare_device(
        '_Z34nvshmemx_qp_ulonglong_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_ulonglong_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z34nvshmemx_qp_ulonglong_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulonglong_get_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_ulonglong_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_ulonglong_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_ulonglong_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_ulonglong_get_nbi_block():
    pass
    

def _lower__Z35nvshmemx_qp_ulonglong_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_qp_ulonglong_get_nbi_block_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulonglong_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z35nvshmemx_qp_ulonglong_get_nbi_block_nbst = declare_device(
        '_Z35nvshmemx_qp_ulonglong_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_qp_ulonglong_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z35nvshmemx_qp_ulonglong_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulonglong_get_nbi_block, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_qp_ulonglong_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_qp_ulonglong_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_qp_ulonglong_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_int8_get_nbi():
    pass
    

def _lower__Z24nvshmemx_qp_int8_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_qp_int8_get_nbi_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int8_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z24nvshmemx_qp_int8_get_nbi_nbst = declare_device(
        '_Z24nvshmemx_qp_int8_get_nbi_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_qp_int8_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmemx_qp_int8_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int8_get_nbi, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_qp_int8_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_qp_int8_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_qp_int8_get_nbi_nbst(shim_stream, shim_obj)


def qp_int8_get_nbi_warp():
    pass
    

def _lower__Z29nvshmemx_qp_int8_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_int8_get_nbi_warp_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int8_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_int8_get_nbi_warp_nbst = declare_device(
        '_Z29nvshmemx_qp_int8_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_int8_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_int8_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int8_get_nbi_warp, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_int8_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_int8_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_int8_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_int8_get_nbi_block():
    pass
    

def _lower__Z30nvshmemx_qp_int8_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_int8_get_nbi_block_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int8_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_int8_get_nbi_block_nbst = declare_device(
        '_Z30nvshmemx_qp_int8_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_int8_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_int8_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int8_get_nbi_block, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_int8_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_int8_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_int8_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_int16_get_nbi():
    pass
    

def _lower__Z25nvshmemx_qp_int16_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_int16_get_nbi_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int16_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_int16_get_nbi_nbst = declare_device(
        '_Z25nvshmemx_qp_int16_get_nbi_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_int16_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_int16_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int16_get_nbi, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_int16_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_int16_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_int16_get_nbi_nbst(shim_stream, shim_obj)


def qp_int16_get_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_qp_int16_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_int16_get_nbi_warp_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int16_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_int16_get_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_int16_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_int16_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_int16_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int16_get_nbi_warp, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_int16_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_int16_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_int16_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_int16_get_nbi_block():
    pass
    

def _lower__Z31nvshmemx_qp_int16_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_int16_get_nbi_block_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int16_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_int16_get_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_qp_int16_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_int16_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_int16_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int16_get_nbi_block, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_int16_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_int16_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_int16_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_int32_get_nbi():
    pass
    

def _lower__Z25nvshmemx_qp_int32_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_int32_get_nbi_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int32_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_int32_get_nbi_nbst = declare_device(
        '_Z25nvshmemx_qp_int32_get_nbi_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_int32_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_int32_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int32_get_nbi, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_int32_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_int32_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_int32_get_nbi_nbst(shim_stream, shim_obj)


def qp_int32_get_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_qp_int32_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_int32_get_nbi_warp_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int32_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_int32_get_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_int32_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_int32_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_int32_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int32_get_nbi_warp, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_int32_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_int32_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_int32_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_int32_get_nbi_block():
    pass
    

def _lower__Z31nvshmemx_qp_int32_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_int32_get_nbi_block_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int32_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_int32_get_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_qp_int32_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_int32_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_int32_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int32_get_nbi_block, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_int32_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_int32_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_int32_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_int64_get_nbi():
    pass
    

def _lower__Z25nvshmemx_qp_int64_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_int64_get_nbi_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int64_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_int64_get_nbi_nbst = declare_device(
        '_Z25nvshmemx_qp_int64_get_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_int64_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_int64_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int64_get_nbi, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_int64_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_int64_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_int64_get_nbi_nbst(shim_stream, shim_obj)


def qp_int64_get_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_qp_int64_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_int64_get_nbi_warp_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int64_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_int64_get_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_int64_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_int64_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_int64_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int64_get_nbi_warp, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_int64_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_int64_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_int64_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_int64_get_nbi_block():
    pass
    

def _lower__Z31nvshmemx_qp_int64_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_int64_get_nbi_block_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int64_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_int64_get_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_qp_int64_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_int64_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_int64_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int64_get_nbi_block, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_int64_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_int64_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_int64_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_uint8_get_nbi():
    pass
    

def _lower__Z25nvshmemx_qp_uint8_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_uint8_get_nbi_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint8_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_uint8_get_nbi_nbst = declare_device(
        '_Z25nvshmemx_qp_uint8_get_nbi_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_uint8_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_uint8_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint8_get_nbi, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_uint8_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_uint8_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_uint8_get_nbi_nbst(shim_stream, shim_obj)


def qp_uint8_get_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_qp_uint8_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_uint8_get_nbi_warp_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint8_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_uint8_get_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_uint8_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_uint8_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_uint8_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint8_get_nbi_warp, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_uint8_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_uint8_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_uint8_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_uint8_get_nbi_block():
    pass
    

def _lower__Z31nvshmemx_qp_uint8_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_uint8_get_nbi_block_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint8_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_uint8_get_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_qp_uint8_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_uint8_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_uint8_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint8_get_nbi_block, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_uint8_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_uint8_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_uint8_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_uint16_get_nbi():
    pass
    

def _lower__Z26nvshmemx_qp_uint16_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_uint16_get_nbi_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint16_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_uint16_get_nbi_nbst = declare_device(
        '_Z26nvshmemx_qp_uint16_get_nbi_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_uint16_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_uint16_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint16_get_nbi, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_uint16_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_uint16_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_uint16_get_nbi_nbst(shim_stream, shim_obj)


def qp_uint16_get_nbi_warp():
    pass
    

def _lower__Z31nvshmemx_qp_uint16_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_uint16_get_nbi_warp_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint16_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_uint16_get_nbi_warp_nbst = declare_device(
        '_Z31nvshmemx_qp_uint16_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_uint16_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_uint16_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint16_get_nbi_warp, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_uint16_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_uint16_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_uint16_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_uint16_get_nbi_block():
    pass
    

def _lower__Z32nvshmemx_qp_uint16_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_uint16_get_nbi_block_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint16_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_uint16_get_nbi_block_nbst = declare_device(
        '_Z32nvshmemx_qp_uint16_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_uint16_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z32nvshmemx_qp_uint16_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint16_get_nbi_block, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_uint16_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_uint16_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_uint16_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_uint32_get_nbi():
    pass
    

def _lower__Z26nvshmemx_qp_uint32_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_uint32_get_nbi_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint32_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_uint32_get_nbi_nbst = declare_device(
        '_Z26nvshmemx_qp_uint32_get_nbi_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_uint32_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_uint32_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint32_get_nbi, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_uint32_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_uint32_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_uint32_get_nbi_nbst(shim_stream, shim_obj)


def qp_uint32_get_nbi_warp():
    pass
    

def _lower__Z31nvshmemx_qp_uint32_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_uint32_get_nbi_warp_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint32_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_uint32_get_nbi_warp_nbst = declare_device(
        '_Z31nvshmemx_qp_uint32_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_uint32_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_uint32_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint32_get_nbi_warp, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_uint32_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_uint32_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_uint32_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_uint32_get_nbi_block():
    pass
    

def _lower__Z32nvshmemx_qp_uint32_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_uint32_get_nbi_block_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint32_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_uint32_get_nbi_block_nbst = declare_device(
        '_Z32nvshmemx_qp_uint32_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_uint32_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z32nvshmemx_qp_uint32_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint32_get_nbi_block, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_uint32_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_uint32_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_uint32_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_uint64_get_nbi():
    pass
    

def _lower__Z26nvshmemx_qp_uint64_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_uint64_get_nbi_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint64_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_uint64_get_nbi_nbst = declare_device(
        '_Z26nvshmemx_qp_uint64_get_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_uint64_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_uint64_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint64_get_nbi, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_uint64_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_uint64_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_uint64_get_nbi_nbst(shim_stream, shim_obj)


def qp_uint64_get_nbi_warp():
    pass
    

def _lower__Z31nvshmemx_qp_uint64_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_uint64_get_nbi_warp_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint64_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_uint64_get_nbi_warp_nbst = declare_device(
        '_Z31nvshmemx_qp_uint64_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_uint64_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_uint64_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint64_get_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_uint64_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_uint64_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_uint64_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_uint64_get_nbi_block():
    pass
    

def _lower__Z32nvshmemx_qp_uint64_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_uint64_get_nbi_block_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint64_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_uint64_get_nbi_block_nbst = declare_device(
        '_Z32nvshmemx_qp_uint64_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_uint64_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z32nvshmemx_qp_uint64_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint64_get_nbi_block, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_uint64_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_uint64_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_uint64_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_size_get_nbi():
    pass
    

def _lower__Z24nvshmemx_qp_size_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_qp_size_get_nbi_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_size_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z24nvshmemx_qp_size_get_nbi_nbst = declare_device(
        '_Z24nvshmemx_qp_size_get_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_qp_size_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmemx_qp_size_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_size_get_nbi, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_qp_size_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_qp_size_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_qp_size_get_nbi_nbst(shim_stream, shim_obj)


def qp_size_get_nbi_warp():
    pass
    

def _lower__Z29nvshmemx_qp_size_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_size_get_nbi_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_size_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_size_get_nbi_warp_nbst = declare_device(
        '_Z29nvshmemx_qp_size_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_size_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_size_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_size_get_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_size_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_size_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_size_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_size_get_nbi_block():
    pass
    

def _lower__Z30nvshmemx_qp_size_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_size_get_nbi_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_size_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_size_get_nbi_block_nbst = declare_device(
        '_Z30nvshmemx_qp_size_get_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_size_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_size_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_size_get_nbi_block, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_size_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_size_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_size_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_ptrdiff_get_nbi():
    pass
    

def _lower__Z27nvshmemx_qp_ptrdiff_get_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_ptrdiff_get_nbi_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ptrdiff_get_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_ptrdiff_get_nbi_nbst = declare_device(
        '_Z27nvshmemx_qp_ptrdiff_get_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_ptrdiff_get_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_ptrdiff_get_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ptrdiff_get_nbi, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_ptrdiff_get_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_ptrdiff_get_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_ptrdiff_get_nbi_nbst(shim_stream, shim_obj)


def qp_ptrdiff_get_nbi_warp():
    pass
    

def _lower__Z32nvshmemx_qp_ptrdiff_get_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_ptrdiff_get_nbi_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ptrdiff_get_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_ptrdiff_get_nbi_warp_nbst = declare_device(
        '_Z32nvshmemx_qp_ptrdiff_get_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_ptrdiff_get_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z32nvshmemx_qp_ptrdiff_get_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ptrdiff_get_nbi_warp, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_ptrdiff_get_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_ptrdiff_get_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_ptrdiff_get_nbi_warp_nbst(shim_stream, shim_obj)


def qp_ptrdiff_get_nbi_block():
    pass
    

def _lower__Z33nvshmemx_qp_ptrdiff_get_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_ptrdiff_get_nbi_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ptrdiff_get_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_ptrdiff_get_nbi_block_nbst = declare_device(
        '_Z33nvshmemx_qp_ptrdiff_get_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_ptrdiff_get_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z33nvshmemx_qp_ptrdiff_get_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ptrdiff_get_nbi_block, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_ptrdiff_get_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_ptrdiff_get_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_ptrdiff_get_nbi_block_nbst(shim_stream, shim_obj)


def qp_bfloat16_put():
    pass
    

def _lower__Z24nvshmemx_qp_bfloat16_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_qp_bfloat16_put_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_bfloat16_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z24nvshmemx_qp_bfloat16_put_nbst = declare_device(
        '_Z24nvshmemx_qp_bfloat16_put_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_qp_bfloat16_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmemx_qp_bfloat16_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_bfloat16_put, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_qp_bfloat16_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_qp_bfloat16_put_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_qp_bfloat16_put_nbst(shim_stream, shim_obj)


def qp_bfloat16_put_warp():
    pass
    

def _lower__Z29nvshmemx_qp_bfloat16_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_bfloat16_put_warp_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_bfloat16_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_bfloat16_put_warp_nbst = declare_device(
        '_Z29nvshmemx_qp_bfloat16_put_warp_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_bfloat16_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_bfloat16_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_bfloat16_put_warp, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_bfloat16_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_bfloat16_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_bfloat16_put_warp_nbst(shim_stream, shim_obj)


def qp_bfloat16_put_block():
    pass
    

def _lower__Z30nvshmemx_qp_bfloat16_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_bfloat16_put_block_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_bfloat16_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_bfloat16_put_block_nbst = declare_device(
        '_Z30nvshmemx_qp_bfloat16_put_block_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_bfloat16_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_bfloat16_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_bfloat16_put_block, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_bfloat16_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_bfloat16_put_block_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_bfloat16_put_block_nbst(shim_stream, shim_obj)


def qp_half_put():
    pass
    

def _lower__Z20nvshmemx_qp_half_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_half_put_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_half_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_half_put_nbst = declare_device(
        '_Z20nvshmemx_qp_half_put_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_half_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z20nvshmemx_qp_half_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_half_put, CPointer(float16), CPointer(float16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_half_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_half_put_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_half_put_nbst(shim_stream, shim_obj)


def qp_half_put_warp():
    pass
    

def _lower__Z25nvshmemx_qp_half_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_half_put_warp_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_half_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_half_put_warp_nbst = declare_device(
        '_Z25nvshmemx_qp_half_put_warp_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_half_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_half_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_half_put_warp, CPointer(float16), CPointer(float16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_half_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_half_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_half_put_warp_nbst(shim_stream, shim_obj)


def qp_half_put_block():
    pass
    

def _lower__Z26nvshmemx_qp_half_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_half_put_block_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_half_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_half_put_block_nbst = declare_device(
        '_Z26nvshmemx_qp_half_put_block_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_half_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_half_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_half_put_block, CPointer(float16), CPointer(float16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_half_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_half_put_block_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_half_put_block_nbst(shim_stream, shim_obj)


def qp_float_put():
    pass
    

def _lower__Z21nvshmemx_qp_float_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_float_put_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_float_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_float_put_nbst = declare_device(
        '_Z21nvshmemx_qp_float_put_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_float_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmemx_qp_float_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_float_put, CPointer(float32), CPointer(float32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_float_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_float_put_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_float_put_nbst(shim_stream, shim_obj)


def qp_float_put_warp():
    pass
    

def _lower__Z26nvshmemx_qp_float_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_float_put_warp_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_float_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_float_put_warp_nbst = declare_device(
        '_Z26nvshmemx_qp_float_put_warp_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_float_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_float_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_float_put_warp, CPointer(float32), CPointer(float32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_float_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_float_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_float_put_warp_nbst(shim_stream, shim_obj)


def qp_float_put_block():
    pass
    

def _lower__Z27nvshmemx_qp_float_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_float_put_block_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_float_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_float_put_block_nbst = declare_device(
        '_Z27nvshmemx_qp_float_put_block_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_float_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_float_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_float_put_block, CPointer(float32), CPointer(float32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_float_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_float_put_block_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_float_put_block_nbst(shim_stream, shim_obj)


def qp_double_put():
    pass
    

def _lower__Z22nvshmemx_qp_double_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_qp_double_put_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_double_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z22nvshmemx_qp_double_put_nbst = declare_device(
        '_Z22nvshmemx_qp_double_put_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_qp_double_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z22nvshmemx_qp_double_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_double_put, CPointer(float64), CPointer(float64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_qp_double_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_qp_double_put_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_qp_double_put_nbst(shim_stream, shim_obj)


def qp_double_put_warp():
    pass
    

def _lower__Z27nvshmemx_qp_double_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_double_put_warp_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_double_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_double_put_warp_nbst = declare_device(
        '_Z27nvshmemx_qp_double_put_warp_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_double_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_double_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_double_put_warp, CPointer(float64), CPointer(float64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_double_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_double_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_double_put_warp_nbst(shim_stream, shim_obj)


def qp_double_put_block():
    pass
    

def _lower__Z28nvshmemx_qp_double_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_double_put_block_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_double_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_double_put_block_nbst = declare_device(
        '_Z28nvshmemx_qp_double_put_block_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_double_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmemx_qp_double_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_double_put_block, CPointer(float64), CPointer(float64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_double_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_double_put_block_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_double_put_block_nbst(shim_stream, shim_obj)


def qp_char_put():
    pass
    

def _lower__Z20nvshmemx_qp_char_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_char_put_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_char_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_char_put_nbst = declare_device(
        '_Z20nvshmemx_qp_char_put_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_char_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z20nvshmemx_qp_char_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_char_put, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_char_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_char_put_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_char_put_nbst(shim_stream, shim_obj)


def qp_char_put_warp():
    pass
    

def _lower__Z25nvshmemx_qp_char_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_char_put_warp_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_char_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_char_put_warp_nbst = declare_device(
        '_Z25nvshmemx_qp_char_put_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_char_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_char_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_char_put_warp, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_char_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_char_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_char_put_warp_nbst(shim_stream, shim_obj)


def qp_char_put_block():
    pass
    

def _lower__Z26nvshmemx_qp_char_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_char_put_block_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_char_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_char_put_block_nbst = declare_device(
        '_Z26nvshmemx_qp_char_put_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_char_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_char_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_char_put_block, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_char_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_char_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_char_put_block_nbst(shim_stream, shim_obj)


def qp_short_put():
    pass
    

def _lower__Z21nvshmemx_qp_short_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_short_put_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_short_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_short_put_nbst = declare_device(
        '_Z21nvshmemx_qp_short_put_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_short_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmemx_qp_short_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_short_put, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_short_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_short_put_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_short_put_nbst(shim_stream, shim_obj)


def qp_short_put_warp():
    pass
    

def _lower__Z26nvshmemx_qp_short_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_short_put_warp_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_short_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_short_put_warp_nbst = declare_device(
        '_Z26nvshmemx_qp_short_put_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_short_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_short_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_short_put_warp, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_short_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_short_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_short_put_warp_nbst(shim_stream, shim_obj)


def qp_short_put_block():
    pass
    

def _lower__Z27nvshmemx_qp_short_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_short_put_block_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_short_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_short_put_block_nbst = declare_device(
        '_Z27nvshmemx_qp_short_put_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_short_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_short_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_short_put_block, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_short_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_short_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_short_put_block_nbst(shim_stream, shim_obj)


def qp_schar_put():
    pass
    

def _lower__Z21nvshmemx_qp_schar_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_schar_put_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_schar_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_schar_put_nbst = declare_device(
        '_Z21nvshmemx_qp_schar_put_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_schar_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmemx_qp_schar_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_schar_put, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_schar_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_schar_put_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_schar_put_nbst(shim_stream, shim_obj)


def qp_schar_put_warp():
    pass
    

def _lower__Z26nvshmemx_qp_schar_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_schar_put_warp_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_schar_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_schar_put_warp_nbst = declare_device(
        '_Z26nvshmemx_qp_schar_put_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_schar_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_schar_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_schar_put_warp, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_schar_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_schar_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_schar_put_warp_nbst(shim_stream, shim_obj)


def qp_schar_put_block():
    pass
    

def _lower__Z27nvshmemx_qp_schar_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_schar_put_block_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_schar_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_schar_put_block_nbst = declare_device(
        '_Z27nvshmemx_qp_schar_put_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_schar_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_schar_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_schar_put_block, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_schar_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_schar_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_schar_put_block_nbst(shim_stream, shim_obj)


def qp_int_put():
    pass
    

def _lower__Z19nvshmemx_qp_int_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_int_put_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_int_put_nbst = declare_device(
        '_Z19nvshmemx_qp_int_put_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_int_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z19nvshmemx_qp_int_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int_put, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_int_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_int_put_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_int_put_nbst(shim_stream, shim_obj)


def qp_int_put_warp():
    pass
    

def _lower__Z24nvshmemx_qp_int_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_qp_int_put_warp_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z24nvshmemx_qp_int_put_warp_nbst = declare_device(
        '_Z24nvshmemx_qp_int_put_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_qp_int_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmemx_qp_int_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int_put_warp, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_qp_int_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_qp_int_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_qp_int_put_warp_nbst(shim_stream, shim_obj)


def qp_int_put_block():
    pass
    

def _lower__Z25nvshmemx_qp_int_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_int_put_block_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_int_put_block_nbst = declare_device(
        '_Z25nvshmemx_qp_int_put_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_int_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_int_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int_put_block, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_int_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_int_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_int_put_block_nbst(shim_stream, shim_obj)


def qp_long_put():
    pass
    

def _lower__Z20nvshmemx_qp_long_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_long_put_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_long_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_long_put_nbst = declare_device(
        '_Z20nvshmemx_qp_long_put_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_long_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z20nvshmemx_qp_long_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_long_put, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_long_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_long_put_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_long_put_nbst(shim_stream, shim_obj)


def qp_long_put_warp():
    pass
    

def _lower__Z25nvshmemx_qp_long_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_long_put_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_long_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_long_put_warp_nbst = declare_device(
        '_Z25nvshmemx_qp_long_put_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_long_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_long_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_long_put_warp, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_long_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_long_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_long_put_warp_nbst(shim_stream, shim_obj)


def qp_long_put_block():
    pass
    

def _lower__Z26nvshmemx_qp_long_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_long_put_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_long_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_long_put_block_nbst = declare_device(
        '_Z26nvshmemx_qp_long_put_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_long_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_long_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_long_put_block, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_long_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_long_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_long_put_block_nbst(shim_stream, shim_obj)


def qp_longlong_put():
    pass
    

def _lower__Z24nvshmemx_qp_longlong_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_qp_longlong_put_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_longlong_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z24nvshmemx_qp_longlong_put_nbst = declare_device(
        '_Z24nvshmemx_qp_longlong_put_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_qp_longlong_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmemx_qp_longlong_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_longlong_put, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_qp_longlong_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_qp_longlong_put_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_qp_longlong_put_nbst(shim_stream, shim_obj)


def qp_longlong_put_warp():
    pass
    

def _lower__Z29nvshmemx_qp_longlong_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_longlong_put_warp_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_longlong_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_longlong_put_warp_nbst = declare_device(
        '_Z29nvshmemx_qp_longlong_put_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_longlong_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_longlong_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_longlong_put_warp, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_longlong_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_longlong_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_longlong_put_warp_nbst(shim_stream, shim_obj)


def qp_longlong_put_block():
    pass
    

def _lower__Z30nvshmemx_qp_longlong_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_longlong_put_block_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_longlong_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_longlong_put_block_nbst = declare_device(
        '_Z30nvshmemx_qp_longlong_put_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_longlong_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_longlong_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_longlong_put_block, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_longlong_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_longlong_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_longlong_put_block_nbst(shim_stream, shim_obj)


def qp_uchar_put():
    pass
    

def _lower__Z21nvshmemx_qp_uchar_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_uchar_put_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uchar_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_uchar_put_nbst = declare_device(
        '_Z21nvshmemx_qp_uchar_put_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_uchar_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmemx_qp_uchar_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uchar_put, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_uchar_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_uchar_put_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_uchar_put_nbst(shim_stream, shim_obj)


def qp_uchar_put_warp():
    pass
    

def _lower__Z26nvshmemx_qp_uchar_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_uchar_put_warp_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uchar_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_uchar_put_warp_nbst = declare_device(
        '_Z26nvshmemx_qp_uchar_put_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_uchar_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_uchar_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uchar_put_warp, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_uchar_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_uchar_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_uchar_put_warp_nbst(shim_stream, shim_obj)


def qp_uchar_put_block():
    pass
    

def _lower__Z27nvshmemx_qp_uchar_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_uchar_put_block_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uchar_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_uchar_put_block_nbst = declare_device(
        '_Z27nvshmemx_qp_uchar_put_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_uchar_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_uchar_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uchar_put_block, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_uchar_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_uchar_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_uchar_put_block_nbst(shim_stream, shim_obj)


def qp_ushort_put():
    pass
    

def _lower__Z22nvshmemx_qp_ushort_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_qp_ushort_put_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ushort_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z22nvshmemx_qp_ushort_put_nbst = declare_device(
        '_Z22nvshmemx_qp_ushort_put_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_qp_ushort_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z22nvshmemx_qp_ushort_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ushort_put, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_qp_ushort_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_qp_ushort_put_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_qp_ushort_put_nbst(shim_stream, shim_obj)


def qp_ushort_put_warp():
    pass
    

def _lower__Z27nvshmemx_qp_ushort_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_ushort_put_warp_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ushort_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_ushort_put_warp_nbst = declare_device(
        '_Z27nvshmemx_qp_ushort_put_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_ushort_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_ushort_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ushort_put_warp, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_ushort_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_ushort_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_ushort_put_warp_nbst(shim_stream, shim_obj)


def qp_ushort_put_block():
    pass
    

def _lower__Z28nvshmemx_qp_ushort_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_ushort_put_block_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ushort_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_ushort_put_block_nbst = declare_device(
        '_Z28nvshmemx_qp_ushort_put_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_ushort_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmemx_qp_ushort_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ushort_put_block, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_ushort_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_ushort_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_ushort_put_block_nbst(shim_stream, shim_obj)


def qp_uint_put():
    pass
    

def _lower__Z20nvshmemx_qp_uint_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_uint_put_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_uint_put_nbst = declare_device(
        '_Z20nvshmemx_qp_uint_put_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_uint_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z20nvshmemx_qp_uint_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint_put, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_uint_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_uint_put_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_uint_put_nbst(shim_stream, shim_obj)


def qp_uint_put_warp():
    pass
    

def _lower__Z25nvshmemx_qp_uint_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_uint_put_warp_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_uint_put_warp_nbst = declare_device(
        '_Z25nvshmemx_qp_uint_put_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_uint_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_uint_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint_put_warp, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_uint_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_uint_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_uint_put_warp_nbst(shim_stream, shim_obj)


def qp_uint_put_block():
    pass
    

def _lower__Z26nvshmemx_qp_uint_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_uint_put_block_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_uint_put_block_nbst = declare_device(
        '_Z26nvshmemx_qp_uint_put_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_uint_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_uint_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint_put_block, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_uint_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_uint_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_uint_put_block_nbst(shim_stream, shim_obj)


def qp_ulong_put():
    pass
    

def _lower__Z21nvshmemx_qp_ulong_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_ulong_put_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulong_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_ulong_put_nbst = declare_device(
        '_Z21nvshmemx_qp_ulong_put_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_ulong_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmemx_qp_ulong_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulong_put, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_ulong_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_ulong_put_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_ulong_put_nbst(shim_stream, shim_obj)


def qp_ulong_put_warp():
    pass
    

def _lower__Z26nvshmemx_qp_ulong_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_ulong_put_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulong_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_ulong_put_warp_nbst = declare_device(
        '_Z26nvshmemx_qp_ulong_put_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_ulong_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_ulong_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulong_put_warp, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_ulong_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_ulong_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_ulong_put_warp_nbst(shim_stream, shim_obj)


def qp_ulong_put_block():
    pass
    

def _lower__Z27nvshmemx_qp_ulong_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_ulong_put_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulong_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_ulong_put_block_nbst = declare_device(
        '_Z27nvshmemx_qp_ulong_put_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_ulong_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_ulong_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulong_put_block, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_ulong_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_ulong_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_ulong_put_block_nbst(shim_stream, shim_obj)


def qp_ulonglong_put():
    pass
    

def _lower__Z25nvshmemx_qp_ulonglong_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_ulonglong_put_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulonglong_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_ulonglong_put_nbst = declare_device(
        '_Z25nvshmemx_qp_ulonglong_put_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_ulonglong_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_ulonglong_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulonglong_put, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_ulonglong_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_ulonglong_put_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_ulonglong_put_nbst(shim_stream, shim_obj)


def qp_ulonglong_put_warp():
    pass
    

def _lower__Z30nvshmemx_qp_ulonglong_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_ulonglong_put_warp_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulonglong_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_ulonglong_put_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_ulonglong_put_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_ulonglong_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_ulonglong_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulonglong_put_warp, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_ulonglong_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_ulonglong_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_ulonglong_put_warp_nbst(shim_stream, shim_obj)


def qp_ulonglong_put_block():
    pass
    

def _lower__Z31nvshmemx_qp_ulonglong_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_ulonglong_put_block_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulonglong_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_ulonglong_put_block_nbst = declare_device(
        '_Z31nvshmemx_qp_ulonglong_put_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_ulonglong_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_ulonglong_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulonglong_put_block, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_ulonglong_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_ulonglong_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_ulonglong_put_block_nbst(shim_stream, shim_obj)


def qp_int8_put():
    pass
    

def _lower__Z20nvshmemx_qp_int8_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_int8_put_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int8_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_int8_put_nbst = declare_device(
        '_Z20nvshmemx_qp_int8_put_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_int8_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z20nvshmemx_qp_int8_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int8_put, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_int8_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_int8_put_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_int8_put_nbst(shim_stream, shim_obj)


def qp_int8_put_warp():
    pass
    

def _lower__Z25nvshmemx_qp_int8_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_int8_put_warp_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int8_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_int8_put_warp_nbst = declare_device(
        '_Z25nvshmemx_qp_int8_put_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_int8_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_int8_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int8_put_warp, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_int8_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_int8_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_int8_put_warp_nbst(shim_stream, shim_obj)


def qp_int8_put_block():
    pass
    

def _lower__Z26nvshmemx_qp_int8_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_int8_put_block_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int8_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_int8_put_block_nbst = declare_device(
        '_Z26nvshmemx_qp_int8_put_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_int8_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_int8_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int8_put_block, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_int8_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_int8_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_int8_put_block_nbst(shim_stream, shim_obj)


def qp_int16_put():
    pass
    

def _lower__Z21nvshmemx_qp_int16_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_int16_put_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int16_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_int16_put_nbst = declare_device(
        '_Z21nvshmemx_qp_int16_put_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_int16_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmemx_qp_int16_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int16_put, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_int16_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_int16_put_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_int16_put_nbst(shim_stream, shim_obj)


def qp_int16_put_warp():
    pass
    

def _lower__Z26nvshmemx_qp_int16_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_int16_put_warp_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int16_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_int16_put_warp_nbst = declare_device(
        '_Z26nvshmemx_qp_int16_put_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_int16_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_int16_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int16_put_warp, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_int16_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_int16_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_int16_put_warp_nbst(shim_stream, shim_obj)


def qp_int16_put_block():
    pass
    

def _lower__Z27nvshmemx_qp_int16_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_int16_put_block_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int16_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_int16_put_block_nbst = declare_device(
        '_Z27nvshmemx_qp_int16_put_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_int16_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_int16_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int16_put_block, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_int16_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_int16_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_int16_put_block_nbst(shim_stream, shim_obj)


def qp_int32_put():
    pass
    

def _lower__Z21nvshmemx_qp_int32_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_int32_put_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int32_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_int32_put_nbst = declare_device(
        '_Z21nvshmemx_qp_int32_put_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_int32_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmemx_qp_int32_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int32_put, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_int32_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_int32_put_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_int32_put_nbst(shim_stream, shim_obj)


def qp_int32_put_warp():
    pass
    

def _lower__Z26nvshmemx_qp_int32_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_int32_put_warp_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int32_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_int32_put_warp_nbst = declare_device(
        '_Z26nvshmemx_qp_int32_put_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_int32_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_int32_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int32_put_warp, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_int32_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_int32_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_int32_put_warp_nbst(shim_stream, shim_obj)


def qp_int32_put_block():
    pass
    

def _lower__Z27nvshmemx_qp_int32_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_int32_put_block_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int32_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_int32_put_block_nbst = declare_device(
        '_Z27nvshmemx_qp_int32_put_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_int32_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_int32_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int32_put_block, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_int32_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_int32_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_int32_put_block_nbst(shim_stream, shim_obj)


def qp_int64_put():
    pass
    

def _lower__Z21nvshmemx_qp_int64_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_int64_put_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int64_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_int64_put_nbst = declare_device(
        '_Z21nvshmemx_qp_int64_put_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_int64_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmemx_qp_int64_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int64_put, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_int64_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_int64_put_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_int64_put_nbst(shim_stream, shim_obj)


def qp_int64_put_warp():
    pass
    

def _lower__Z26nvshmemx_qp_int64_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_int64_put_warp_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int64_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_int64_put_warp_nbst = declare_device(
        '_Z26nvshmemx_qp_int64_put_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_int64_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_int64_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int64_put_warp, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_int64_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_int64_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_int64_put_warp_nbst(shim_stream, shim_obj)


def qp_int64_put_block():
    pass
    

def _lower__Z27nvshmemx_qp_int64_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_int64_put_block_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int64_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_int64_put_block_nbst = declare_device(
        '_Z27nvshmemx_qp_int64_put_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_int64_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_int64_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int64_put_block, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_int64_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_int64_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_int64_put_block_nbst(shim_stream, shim_obj)


def qp_uint8_put():
    pass
    

def _lower__Z21nvshmemx_qp_uint8_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_uint8_put_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint8_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_uint8_put_nbst = declare_device(
        '_Z21nvshmemx_qp_uint8_put_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_uint8_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmemx_qp_uint8_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint8_put, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_uint8_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_uint8_put_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_uint8_put_nbst(shim_stream, shim_obj)


def qp_uint8_put_warp():
    pass
    

def _lower__Z26nvshmemx_qp_uint8_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_uint8_put_warp_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint8_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_uint8_put_warp_nbst = declare_device(
        '_Z26nvshmemx_qp_uint8_put_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_uint8_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_uint8_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint8_put_warp, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_uint8_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_uint8_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_uint8_put_warp_nbst(shim_stream, shim_obj)


def qp_uint8_put_block():
    pass
    

def _lower__Z27nvshmemx_qp_uint8_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_uint8_put_block_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint8_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_uint8_put_block_nbst = declare_device(
        '_Z27nvshmemx_qp_uint8_put_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_uint8_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_uint8_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint8_put_block, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_uint8_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_uint8_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_uint8_put_block_nbst(shim_stream, shim_obj)


def qp_uint16_put():
    pass
    

def _lower__Z22nvshmemx_qp_uint16_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_qp_uint16_put_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint16_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z22nvshmemx_qp_uint16_put_nbst = declare_device(
        '_Z22nvshmemx_qp_uint16_put_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_qp_uint16_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z22nvshmemx_qp_uint16_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint16_put, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_qp_uint16_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_qp_uint16_put_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_qp_uint16_put_nbst(shim_stream, shim_obj)


def qp_uint16_put_warp():
    pass
    

def _lower__Z27nvshmemx_qp_uint16_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_uint16_put_warp_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint16_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_uint16_put_warp_nbst = declare_device(
        '_Z27nvshmemx_qp_uint16_put_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_uint16_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_uint16_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint16_put_warp, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_uint16_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_uint16_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_uint16_put_warp_nbst(shim_stream, shim_obj)


def qp_uint16_put_block():
    pass
    

def _lower__Z28nvshmemx_qp_uint16_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_uint16_put_block_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint16_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_uint16_put_block_nbst = declare_device(
        '_Z28nvshmemx_qp_uint16_put_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_uint16_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmemx_qp_uint16_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint16_put_block, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_uint16_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_uint16_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_uint16_put_block_nbst(shim_stream, shim_obj)


def qp_uint32_put():
    pass
    

def _lower__Z22nvshmemx_qp_uint32_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_qp_uint32_put_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint32_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z22nvshmemx_qp_uint32_put_nbst = declare_device(
        '_Z22nvshmemx_qp_uint32_put_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_qp_uint32_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z22nvshmemx_qp_uint32_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint32_put, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_qp_uint32_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_qp_uint32_put_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_qp_uint32_put_nbst(shim_stream, shim_obj)


def qp_uint32_put_warp():
    pass
    

def _lower__Z27nvshmemx_qp_uint32_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_uint32_put_warp_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint32_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_uint32_put_warp_nbst = declare_device(
        '_Z27nvshmemx_qp_uint32_put_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_uint32_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_uint32_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint32_put_warp, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_uint32_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_uint32_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_uint32_put_warp_nbst(shim_stream, shim_obj)


def qp_uint32_put_block():
    pass
    

def _lower__Z28nvshmemx_qp_uint32_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_uint32_put_block_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint32_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_uint32_put_block_nbst = declare_device(
        '_Z28nvshmemx_qp_uint32_put_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_uint32_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmemx_qp_uint32_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint32_put_block, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_uint32_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_uint32_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_uint32_put_block_nbst(shim_stream, shim_obj)


def qp_uint64_put():
    pass
    

def _lower__Z22nvshmemx_qp_uint64_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_qp_uint64_put_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint64_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z22nvshmemx_qp_uint64_put_nbst = declare_device(
        '_Z22nvshmemx_qp_uint64_put_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_qp_uint64_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z22nvshmemx_qp_uint64_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint64_put, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_qp_uint64_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_qp_uint64_put_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_qp_uint64_put_nbst(shim_stream, shim_obj)


def qp_uint64_put_warp():
    pass
    

def _lower__Z27nvshmemx_qp_uint64_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_uint64_put_warp_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint64_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_uint64_put_warp_nbst = declare_device(
        '_Z27nvshmemx_qp_uint64_put_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_uint64_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_uint64_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint64_put_warp, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_uint64_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_uint64_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_uint64_put_warp_nbst(shim_stream, shim_obj)


def qp_uint64_put_block():
    pass
    

def _lower__Z28nvshmemx_qp_uint64_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_uint64_put_block_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint64_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_uint64_put_block_nbst = declare_device(
        '_Z28nvshmemx_qp_uint64_put_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_uint64_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmemx_qp_uint64_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint64_put_block, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_uint64_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_uint64_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_uint64_put_block_nbst(shim_stream, shim_obj)


def qp_size_put():
    pass
    

def _lower__Z20nvshmemx_qp_size_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_size_put_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_size_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_size_put_nbst = declare_device(
        '_Z20nvshmemx_qp_size_put_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_size_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z20nvshmemx_qp_size_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_size_put, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_size_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_size_put_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_size_put_nbst(shim_stream, shim_obj)


def qp_size_put_warp():
    pass
    

def _lower__Z25nvshmemx_qp_size_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_size_put_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_size_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_size_put_warp_nbst = declare_device(
        '_Z25nvshmemx_qp_size_put_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_size_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_size_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_size_put_warp, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_size_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_size_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_size_put_warp_nbst(shim_stream, shim_obj)


def qp_size_put_block():
    pass
    

def _lower__Z26nvshmemx_qp_size_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_size_put_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_size_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_size_put_block_nbst = declare_device(
        '_Z26nvshmemx_qp_size_put_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_size_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_size_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_size_put_block, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_size_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_size_put_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_size_put_block_nbst(shim_stream, shim_obj)


def qp_ptrdiff_put():
    pass
    

def _lower__Z23nvshmemx_qp_ptrdiff_put_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_qp_ptrdiff_put_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ptrdiff_put(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z23nvshmemx_qp_ptrdiff_put_nbst = declare_device(
        '_Z23nvshmemx_qp_ptrdiff_put_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_qp_ptrdiff_put_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z23nvshmemx_qp_ptrdiff_put_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ptrdiff_put, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_qp_ptrdiff_put_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_qp_ptrdiff_put_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_qp_ptrdiff_put_nbst(shim_stream, shim_obj)


def qp_ptrdiff_put_warp():
    pass
    

def _lower__Z28nvshmemx_qp_ptrdiff_put_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_ptrdiff_put_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ptrdiff_put_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_ptrdiff_put_warp_nbst = declare_device(
        '_Z28nvshmemx_qp_ptrdiff_put_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_ptrdiff_put_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmemx_qp_ptrdiff_put_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ptrdiff_put_warp, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_ptrdiff_put_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_ptrdiff_put_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_ptrdiff_put_warp_nbst(shim_stream, shim_obj)


def qp_ptrdiff_put_block():
    pass
    

def _lower__Z29nvshmemx_qp_ptrdiff_put_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_ptrdiff_put_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ptrdiff_put_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_ptrdiff_put_block_nbst = declare_device(
        '_Z29nvshmemx_qp_ptrdiff_put_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_ptrdiff_put_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_ptrdiff_put_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ptrdiff_put_block, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_ptrdiff_put_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_ptrdiff_put_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_ptrdiff_put_block_nbst(shim_stream, shim_obj)


def qp_bfloat16_put_nbi():
    pass
    

def _lower__Z28nvshmemx_qp_bfloat16_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_bfloat16_put_nbi_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_bfloat16_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_bfloat16_put_nbi_nbst = declare_device(
        '_Z28nvshmemx_qp_bfloat16_put_nbi_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_bfloat16_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmemx_qp_bfloat16_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_bfloat16_put_nbi, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_bfloat16_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_bfloat16_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_bfloat16_put_nbi_nbst(shim_stream, shim_obj)


def qp_bfloat16_put_nbi_warp():
    pass
    

def _lower__Z33nvshmemx_qp_bfloat16_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_bfloat16_put_nbi_warp_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_bfloat16_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_bfloat16_put_nbi_warp_nbst = declare_device(
        '_Z33nvshmemx_qp_bfloat16_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_bfloat16_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z33nvshmemx_qp_bfloat16_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_bfloat16_put_nbi_warp, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_bfloat16_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_bfloat16_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_bfloat16_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_bfloat16_put_nbi_block():
    pass
    

def _lower__Z34nvshmemx_qp_bfloat16_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_bfloat16_put_nbi_block_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_bfloat16_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_bfloat16_put_nbi_block_nbst = declare_device(
        '_Z34nvshmemx_qp_bfloat16_put_nbi_block_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_bfloat16_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z34nvshmemx_qp_bfloat16_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_bfloat16_put_nbi_block, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_bfloat16_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_bfloat16_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_bfloat16_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_half_put_nbi():
    pass
    

def _lower__Z24nvshmemx_qp_half_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_qp_half_put_nbi_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_half_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z24nvshmemx_qp_half_put_nbi_nbst = declare_device(
        '_Z24nvshmemx_qp_half_put_nbi_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_qp_half_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmemx_qp_half_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_half_put_nbi, CPointer(float16), CPointer(float16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_qp_half_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_qp_half_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_qp_half_put_nbi_nbst(shim_stream, shim_obj)


def qp_half_put_nbi_warp():
    pass
    

def _lower__Z29nvshmemx_qp_half_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_half_put_nbi_warp_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_half_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_half_put_nbi_warp_nbst = declare_device(
        '_Z29nvshmemx_qp_half_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_half_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_half_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_half_put_nbi_warp, CPointer(float16), CPointer(float16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_half_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_half_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_half_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_half_put_nbi_block():
    pass
    

def _lower__Z30nvshmemx_qp_half_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_half_put_nbi_block_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_half_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_half_put_nbi_block_nbst = declare_device(
        '_Z30nvshmemx_qp_half_put_nbi_block_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_half_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_half_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_half_put_nbi_block, CPointer(float16), CPointer(float16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_half_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_half_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_half_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_float_put_nbi():
    pass
    

def _lower__Z25nvshmemx_qp_float_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_float_put_nbi_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_float_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_float_put_nbi_nbst = declare_device(
        '_Z25nvshmemx_qp_float_put_nbi_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_float_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_float_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_float_put_nbi, CPointer(float32), CPointer(float32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_float_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_float_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_float_put_nbi_nbst(shim_stream, shim_obj)


def qp_float_put_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_qp_float_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_float_put_nbi_warp_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_float_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_float_put_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_float_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_float_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_float_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_float_put_nbi_warp, CPointer(float32), CPointer(float32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_float_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_float_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_float_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_float_put_nbi_block():
    pass
    

def _lower__Z31nvshmemx_qp_float_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_float_put_nbi_block_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_float_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_float_put_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_qp_float_put_nbi_block_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_float_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_float_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_float_put_nbi_block, CPointer(float32), CPointer(float32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_float_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_float_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_float_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_double_put_nbi():
    pass
    

def _lower__Z26nvshmemx_qp_double_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_double_put_nbi_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_double_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_double_put_nbi_nbst = declare_device(
        '_Z26nvshmemx_qp_double_put_nbi_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_double_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_double_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_double_put_nbi, CPointer(float64), CPointer(float64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_double_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_double_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_double_put_nbi_nbst(shim_stream, shim_obj)


def qp_double_put_nbi_warp():
    pass
    

def _lower__Z31nvshmemx_qp_double_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_double_put_nbi_warp_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_double_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_double_put_nbi_warp_nbst = declare_device(
        '_Z31nvshmemx_qp_double_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_double_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_double_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_double_put_nbi_warp, CPointer(float64), CPointer(float64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_double_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_double_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_double_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_double_put_nbi_block():
    pass
    

def _lower__Z32nvshmemx_qp_double_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_double_put_nbi_block_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_double_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_double_put_nbi_block_nbst = declare_device(
        '_Z32nvshmemx_qp_double_put_nbi_block_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_double_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z32nvshmemx_qp_double_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_double_put_nbi_block, CPointer(float64), CPointer(float64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_double_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_double_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_double_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_char_put_nbi():
    pass
    

def _lower__Z24nvshmemx_qp_char_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_qp_char_put_nbi_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_char_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z24nvshmemx_qp_char_put_nbi_nbst = declare_device(
        '_Z24nvshmemx_qp_char_put_nbi_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_qp_char_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmemx_qp_char_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_char_put_nbi, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_qp_char_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_qp_char_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_qp_char_put_nbi_nbst(shim_stream, shim_obj)


def qp_char_put_nbi_warp():
    pass
    

def _lower__Z29nvshmemx_qp_char_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_char_put_nbi_warp_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_char_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_char_put_nbi_warp_nbst = declare_device(
        '_Z29nvshmemx_qp_char_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_char_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_char_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_char_put_nbi_warp, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_char_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_char_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_char_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_char_put_nbi_block():
    pass
    

def _lower__Z30nvshmemx_qp_char_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_char_put_nbi_block_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_char_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_char_put_nbi_block_nbst = declare_device(
        '_Z30nvshmemx_qp_char_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_char_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_char_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_char_put_nbi_block, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_char_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_char_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_char_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_short_put_nbi():
    pass
    

def _lower__Z25nvshmemx_qp_short_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_short_put_nbi_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_short_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_short_put_nbi_nbst = declare_device(
        '_Z25nvshmemx_qp_short_put_nbi_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_short_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_short_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_short_put_nbi, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_short_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_short_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_short_put_nbi_nbst(shim_stream, shim_obj)


def qp_short_put_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_qp_short_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_short_put_nbi_warp_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_short_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_short_put_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_short_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_short_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_short_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_short_put_nbi_warp, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_short_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_short_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_short_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_short_put_nbi_block():
    pass
    

def _lower__Z31nvshmemx_qp_short_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_short_put_nbi_block_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_short_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_short_put_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_qp_short_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_short_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_short_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_short_put_nbi_block, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_short_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_short_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_short_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_schar_put_nbi():
    pass
    

def _lower__Z25nvshmemx_qp_schar_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_schar_put_nbi_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_schar_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_schar_put_nbi_nbst = declare_device(
        '_Z25nvshmemx_qp_schar_put_nbi_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_schar_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_schar_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_schar_put_nbi, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_schar_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_schar_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_schar_put_nbi_nbst(shim_stream, shim_obj)


def qp_schar_put_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_qp_schar_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_schar_put_nbi_warp_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_schar_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_schar_put_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_schar_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_schar_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_schar_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_schar_put_nbi_warp, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_schar_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_schar_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_schar_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_schar_put_nbi_block():
    pass
    

def _lower__Z31nvshmemx_qp_schar_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_schar_put_nbi_block_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_schar_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_schar_put_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_qp_schar_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_schar_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_schar_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_schar_put_nbi_block, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_schar_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_schar_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_schar_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_int_put_nbi():
    pass
    

def _lower__Z23nvshmemx_qp_int_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_qp_int_put_nbi_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z23nvshmemx_qp_int_put_nbi_nbst = declare_device(
        '_Z23nvshmemx_qp_int_put_nbi_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_qp_int_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z23nvshmemx_qp_int_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int_put_nbi, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_qp_int_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_qp_int_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_qp_int_put_nbi_nbst(shim_stream, shim_obj)


def qp_int_put_nbi_warp():
    pass
    

def _lower__Z28nvshmemx_qp_int_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_int_put_nbi_warp_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_int_put_nbi_warp_nbst = declare_device(
        '_Z28nvshmemx_qp_int_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_int_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmemx_qp_int_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int_put_nbi_warp, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_int_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_int_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_int_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_int_put_nbi_block():
    pass
    

def _lower__Z29nvshmemx_qp_int_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_int_put_nbi_block_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_int_put_nbi_block_nbst = declare_device(
        '_Z29nvshmemx_qp_int_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_int_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_int_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int_put_nbi_block, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_int_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_int_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_int_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_long_put_nbi():
    pass
    

def _lower__Z24nvshmemx_qp_long_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_qp_long_put_nbi_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_long_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z24nvshmemx_qp_long_put_nbi_nbst = declare_device(
        '_Z24nvshmemx_qp_long_put_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_qp_long_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmemx_qp_long_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_long_put_nbi, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_qp_long_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_qp_long_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_qp_long_put_nbi_nbst(shim_stream, shim_obj)


def qp_long_put_nbi_warp():
    pass
    

def _lower__Z29nvshmemx_qp_long_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_long_put_nbi_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_long_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_long_put_nbi_warp_nbst = declare_device(
        '_Z29nvshmemx_qp_long_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_long_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_long_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_long_put_nbi_warp, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_long_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_long_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_long_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_long_put_nbi_block():
    pass
    

def _lower__Z30nvshmemx_qp_long_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_long_put_nbi_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_long_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_long_put_nbi_block_nbst = declare_device(
        '_Z30nvshmemx_qp_long_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_long_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_long_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_long_put_nbi_block, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_long_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_long_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_long_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_longlong_put_nbi():
    pass
    

def _lower__Z28nvshmemx_qp_longlong_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_longlong_put_nbi_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_longlong_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_longlong_put_nbi_nbst = declare_device(
        '_Z28nvshmemx_qp_longlong_put_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_longlong_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z28nvshmemx_qp_longlong_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_longlong_put_nbi, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_longlong_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_longlong_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_longlong_put_nbi_nbst(shim_stream, shim_obj)


def qp_longlong_put_nbi_warp():
    pass
    

def _lower__Z33nvshmemx_qp_longlong_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_longlong_put_nbi_warp_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_longlong_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_longlong_put_nbi_warp_nbst = declare_device(
        '_Z33nvshmemx_qp_longlong_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_longlong_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z33nvshmemx_qp_longlong_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_longlong_put_nbi_warp, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_longlong_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_longlong_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_longlong_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_longlong_put_nbi_block():
    pass
    

def _lower__Z34nvshmemx_qp_longlong_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_longlong_put_nbi_block_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_longlong_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_longlong_put_nbi_block_nbst = declare_device(
        '_Z34nvshmemx_qp_longlong_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_longlong_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z34nvshmemx_qp_longlong_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_longlong_put_nbi_block, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_longlong_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_longlong_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_longlong_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_uchar_put_nbi():
    pass
    

def _lower__Z25nvshmemx_qp_uchar_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_uchar_put_nbi_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uchar_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_uchar_put_nbi_nbst = declare_device(
        '_Z25nvshmemx_qp_uchar_put_nbi_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_uchar_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_uchar_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uchar_put_nbi, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_uchar_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_uchar_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_uchar_put_nbi_nbst(shim_stream, shim_obj)


def qp_uchar_put_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_qp_uchar_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_uchar_put_nbi_warp_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uchar_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_uchar_put_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_uchar_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_uchar_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_uchar_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uchar_put_nbi_warp, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_uchar_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_uchar_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_uchar_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_uchar_put_nbi_block():
    pass
    

def _lower__Z31nvshmemx_qp_uchar_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_uchar_put_nbi_block_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uchar_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_uchar_put_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_qp_uchar_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_uchar_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_uchar_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uchar_put_nbi_block, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_uchar_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_uchar_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_uchar_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_ushort_put_nbi():
    pass
    

def _lower__Z26nvshmemx_qp_ushort_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_ushort_put_nbi_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ushort_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_ushort_put_nbi_nbst = declare_device(
        '_Z26nvshmemx_qp_ushort_put_nbi_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_ushort_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_ushort_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ushort_put_nbi, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_ushort_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_ushort_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_ushort_put_nbi_nbst(shim_stream, shim_obj)


def qp_ushort_put_nbi_warp():
    pass
    

def _lower__Z31nvshmemx_qp_ushort_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_ushort_put_nbi_warp_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ushort_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_ushort_put_nbi_warp_nbst = declare_device(
        '_Z31nvshmemx_qp_ushort_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_ushort_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_ushort_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ushort_put_nbi_warp, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_ushort_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_ushort_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_ushort_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_ushort_put_nbi_block():
    pass
    

def _lower__Z32nvshmemx_qp_ushort_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_ushort_put_nbi_block_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ushort_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_ushort_put_nbi_block_nbst = declare_device(
        '_Z32nvshmemx_qp_ushort_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_ushort_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z32nvshmemx_qp_ushort_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ushort_put_nbi_block, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_ushort_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_ushort_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_ushort_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_uint_put_nbi():
    pass
    

def _lower__Z24nvshmemx_qp_uint_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_qp_uint_put_nbi_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z24nvshmemx_qp_uint_put_nbi_nbst = declare_device(
        '_Z24nvshmemx_qp_uint_put_nbi_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_qp_uint_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmemx_qp_uint_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint_put_nbi, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_qp_uint_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_qp_uint_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_qp_uint_put_nbi_nbst(shim_stream, shim_obj)


def qp_uint_put_nbi_warp():
    pass
    

def _lower__Z29nvshmemx_qp_uint_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_uint_put_nbi_warp_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_uint_put_nbi_warp_nbst = declare_device(
        '_Z29nvshmemx_qp_uint_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_uint_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_uint_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint_put_nbi_warp, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_uint_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_uint_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_uint_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_uint_put_nbi_block():
    pass
    

def _lower__Z30nvshmemx_qp_uint_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_uint_put_nbi_block_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_uint_put_nbi_block_nbst = declare_device(
        '_Z30nvshmemx_qp_uint_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_uint_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_uint_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint_put_nbi_block, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_uint_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_uint_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_uint_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_ulong_put_nbi():
    pass
    

def _lower__Z25nvshmemx_qp_ulong_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_ulong_put_nbi_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulong_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_ulong_put_nbi_nbst = declare_device(
        '_Z25nvshmemx_qp_ulong_put_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_ulong_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_ulong_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulong_put_nbi, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_ulong_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_ulong_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_ulong_put_nbi_nbst(shim_stream, shim_obj)


def qp_ulong_put_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_qp_ulong_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_ulong_put_nbi_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulong_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_ulong_put_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_ulong_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_ulong_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_ulong_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulong_put_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_ulong_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_ulong_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_ulong_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_ulong_put_nbi_block():
    pass
    

def _lower__Z31nvshmemx_qp_ulong_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_ulong_put_nbi_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulong_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_ulong_put_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_qp_ulong_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_ulong_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_ulong_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulong_put_nbi_block, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_ulong_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_ulong_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_ulong_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_ulonglong_put_nbi():
    pass
    

def _lower__Z29nvshmemx_qp_ulonglong_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_ulonglong_put_nbi_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulonglong_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_ulonglong_put_nbi_nbst = declare_device(
        '_Z29nvshmemx_qp_ulonglong_put_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_ulonglong_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_ulonglong_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulonglong_put_nbi, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_ulonglong_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_ulonglong_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_ulonglong_put_nbi_nbst(shim_stream, shim_obj)


def qp_ulonglong_put_nbi_warp():
    pass
    

def _lower__Z34nvshmemx_qp_ulonglong_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_ulonglong_put_nbi_warp_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulonglong_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_ulonglong_put_nbi_warp_nbst = declare_device(
        '_Z34nvshmemx_qp_ulonglong_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_ulonglong_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z34nvshmemx_qp_ulonglong_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulonglong_put_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_ulonglong_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_ulonglong_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_ulonglong_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_ulonglong_put_nbi_block():
    pass
    

def _lower__Z35nvshmemx_qp_ulonglong_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_qp_ulonglong_put_nbi_block_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ulonglong_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z35nvshmemx_qp_ulonglong_put_nbi_block_nbst = declare_device(
        '_Z35nvshmemx_qp_ulonglong_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_qp_ulonglong_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z35nvshmemx_qp_ulonglong_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ulonglong_put_nbi_block, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_qp_ulonglong_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_qp_ulonglong_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_qp_ulonglong_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_int8_put_nbi():
    pass
    

def _lower__Z24nvshmemx_qp_int8_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_qp_int8_put_nbi_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int8_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z24nvshmemx_qp_int8_put_nbi_nbst = declare_device(
        '_Z24nvshmemx_qp_int8_put_nbi_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_qp_int8_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmemx_qp_int8_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int8_put_nbi, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_qp_int8_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_qp_int8_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_qp_int8_put_nbi_nbst(shim_stream, shim_obj)


def qp_int8_put_nbi_warp():
    pass
    

def _lower__Z29nvshmemx_qp_int8_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_int8_put_nbi_warp_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int8_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_int8_put_nbi_warp_nbst = declare_device(
        '_Z29nvshmemx_qp_int8_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_int8_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_int8_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int8_put_nbi_warp, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_int8_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_int8_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_int8_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_int8_put_nbi_block():
    pass
    

def _lower__Z30nvshmemx_qp_int8_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_int8_put_nbi_block_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int8_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_int8_put_nbi_block_nbst = declare_device(
        '_Z30nvshmemx_qp_int8_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_int8_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_int8_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int8_put_nbi_block, CPointer(int8), CPointer(int8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_int8_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_int8_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_int8_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_int16_put_nbi():
    pass
    

def _lower__Z25nvshmemx_qp_int16_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_int16_put_nbi_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int16_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_int16_put_nbi_nbst = declare_device(
        '_Z25nvshmemx_qp_int16_put_nbi_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_int16_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_int16_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int16_put_nbi, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_int16_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_int16_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_int16_put_nbi_nbst(shim_stream, shim_obj)


def qp_int16_put_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_qp_int16_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_int16_put_nbi_warp_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int16_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_int16_put_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_int16_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_int16_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_int16_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int16_put_nbi_warp, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_int16_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_int16_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_int16_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_int16_put_nbi_block():
    pass
    

def _lower__Z31nvshmemx_qp_int16_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_int16_put_nbi_block_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int16_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_int16_put_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_qp_int16_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_int16_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_int16_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int16_put_nbi_block, CPointer(int16), CPointer(int16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_int16_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_int16_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_int16_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_int32_put_nbi():
    pass
    

def _lower__Z25nvshmemx_qp_int32_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_int32_put_nbi_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int32_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_int32_put_nbi_nbst = declare_device(
        '_Z25nvshmemx_qp_int32_put_nbi_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_int32_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_int32_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int32_put_nbi, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_int32_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_int32_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_int32_put_nbi_nbst(shim_stream, shim_obj)


def qp_int32_put_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_qp_int32_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_int32_put_nbi_warp_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int32_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_int32_put_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_int32_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_int32_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_int32_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int32_put_nbi_warp, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_int32_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_int32_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_int32_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_int32_put_nbi_block():
    pass
    

def _lower__Z31nvshmemx_qp_int32_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_int32_put_nbi_block_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int32_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_int32_put_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_qp_int32_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_int32_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_int32_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int32_put_nbi_block, CPointer(int32), CPointer(int32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_int32_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_int32_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_int32_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_int64_put_nbi():
    pass
    

def _lower__Z25nvshmemx_qp_int64_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_int64_put_nbi_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int64_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_int64_put_nbi_nbst = declare_device(
        '_Z25nvshmemx_qp_int64_put_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_int64_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_int64_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int64_put_nbi, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_int64_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_int64_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_int64_put_nbi_nbst(shim_stream, shim_obj)


def qp_int64_put_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_qp_int64_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_int64_put_nbi_warp_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int64_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_int64_put_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_int64_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_int64_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_int64_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int64_put_nbi_warp, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_int64_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_int64_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_int64_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_int64_put_nbi_block():
    pass
    

def _lower__Z31nvshmemx_qp_int64_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_int64_put_nbi_block_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_int64_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_int64_put_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_qp_int64_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_int64_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_int64_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_int64_put_nbi_block, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_int64_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_int64_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_int64_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_uint8_put_nbi():
    pass
    

def _lower__Z25nvshmemx_qp_uint8_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z25nvshmemx_qp_uint8_put_nbi_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint8_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z25nvshmemx_qp_uint8_put_nbi_nbst = declare_device(
        '_Z25nvshmemx_qp_uint8_put_nbi_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z25nvshmemx_qp_uint8_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z25nvshmemx_qp_uint8_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint8_put_nbi, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z25nvshmemx_qp_uint8_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z25nvshmemx_qp_uint8_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z25nvshmemx_qp_uint8_put_nbi_nbst(shim_stream, shim_obj)


def qp_uint8_put_nbi_warp():
    pass
    

def _lower__Z30nvshmemx_qp_uint8_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_uint8_put_nbi_warp_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint8_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_uint8_put_nbi_warp_nbst = declare_device(
        '_Z30nvshmemx_qp_uint8_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_uint8_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_uint8_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint8_put_nbi_warp, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_uint8_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_uint8_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_uint8_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_uint8_put_nbi_block():
    pass
    

def _lower__Z31nvshmemx_qp_uint8_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_uint8_put_nbi_block_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint8_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_uint8_put_nbi_block_nbst = declare_device(
        '_Z31nvshmemx_qp_uint8_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_uint8_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_uint8_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint8_put_nbi_block, CPointer(uint8), CPointer(uint8), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_uint8_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_uint8_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_uint8_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_uint16_put_nbi():
    pass
    

def _lower__Z26nvshmemx_qp_uint16_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_uint16_put_nbi_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint16_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_uint16_put_nbi_nbst = declare_device(
        '_Z26nvshmemx_qp_uint16_put_nbi_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_uint16_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_uint16_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint16_put_nbi, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_uint16_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_uint16_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_uint16_put_nbi_nbst(shim_stream, shim_obj)


def qp_uint16_put_nbi_warp():
    pass
    

def _lower__Z31nvshmemx_qp_uint16_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_uint16_put_nbi_warp_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint16_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_uint16_put_nbi_warp_nbst = declare_device(
        '_Z31nvshmemx_qp_uint16_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_uint16_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_uint16_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint16_put_nbi_warp, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_uint16_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_uint16_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_uint16_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_uint16_put_nbi_block():
    pass
    

def _lower__Z32nvshmemx_qp_uint16_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_uint16_put_nbi_block_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint16_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_uint16_put_nbi_block_nbst = declare_device(
        '_Z32nvshmemx_qp_uint16_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_uint16_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z32nvshmemx_qp_uint16_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint16_put_nbi_block, CPointer(uint16), CPointer(uint16), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_uint16_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_uint16_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_uint16_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_uint32_put_nbi():
    pass
    

def _lower__Z26nvshmemx_qp_uint32_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_uint32_put_nbi_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint32_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_uint32_put_nbi_nbst = declare_device(
        '_Z26nvshmemx_qp_uint32_put_nbi_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_uint32_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_uint32_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint32_put_nbi, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_uint32_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_uint32_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_uint32_put_nbi_nbst(shim_stream, shim_obj)


def qp_uint32_put_nbi_warp():
    pass
    

def _lower__Z31nvshmemx_qp_uint32_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_uint32_put_nbi_warp_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint32_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_uint32_put_nbi_warp_nbst = declare_device(
        '_Z31nvshmemx_qp_uint32_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_uint32_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_uint32_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint32_put_nbi_warp, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_uint32_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_uint32_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_uint32_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_uint32_put_nbi_block():
    pass
    

def _lower__Z32nvshmemx_qp_uint32_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_uint32_put_nbi_block_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint32_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_uint32_put_nbi_block_nbst = declare_device(
        '_Z32nvshmemx_qp_uint32_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_uint32_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z32nvshmemx_qp_uint32_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint32_put_nbi_block, CPointer(uint32), CPointer(uint32), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_uint32_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_uint32_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_uint32_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_uint64_put_nbi():
    pass
    

def _lower__Z26nvshmemx_qp_uint64_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_uint64_put_nbi_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint64_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_uint64_put_nbi_nbst = declare_device(
        '_Z26nvshmemx_qp_uint64_put_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_uint64_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z26nvshmemx_qp_uint64_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint64_put_nbi, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_uint64_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_uint64_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_uint64_put_nbi_nbst(shim_stream, shim_obj)


def qp_uint64_put_nbi_warp():
    pass
    

def _lower__Z31nvshmemx_qp_uint64_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_uint64_put_nbi_warp_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint64_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_uint64_put_nbi_warp_nbst = declare_device(
        '_Z31nvshmemx_qp_uint64_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_uint64_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z31nvshmemx_qp_uint64_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint64_put_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_uint64_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_uint64_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_uint64_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_uint64_put_nbi_block():
    pass
    

def _lower__Z32nvshmemx_qp_uint64_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_uint64_put_nbi_block_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_uint64_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_uint64_put_nbi_block_nbst = declare_device(
        '_Z32nvshmemx_qp_uint64_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_uint64_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z32nvshmemx_qp_uint64_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_uint64_put_nbi_block, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_uint64_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_uint64_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_uint64_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_size_put_nbi():
    pass
    

def _lower__Z24nvshmemx_qp_size_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z24nvshmemx_qp_size_put_nbi_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_size_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z24nvshmemx_qp_size_put_nbi_nbst = declare_device(
        '_Z24nvshmemx_qp_size_put_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z24nvshmemx_qp_size_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z24nvshmemx_qp_size_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_size_put_nbi, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z24nvshmemx_qp_size_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z24nvshmemx_qp_size_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z24nvshmemx_qp_size_put_nbi_nbst(shim_stream, shim_obj)


def qp_size_put_nbi_warp():
    pass
    

def _lower__Z29nvshmemx_qp_size_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_size_put_nbi_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_size_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_size_put_nbi_warp_nbst = declare_device(
        '_Z29nvshmemx_qp_size_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_size_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z29nvshmemx_qp_size_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_size_put_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_size_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_size_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_size_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_size_put_nbi_block():
    pass
    

def _lower__Z30nvshmemx_qp_size_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_size_put_nbi_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_size_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_size_put_nbi_block_nbst = declare_device(
        '_Z30nvshmemx_qp_size_put_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_size_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z30nvshmemx_qp_size_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_size_put_nbi_block, CPointer(uint64), CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_size_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_size_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_size_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_ptrdiff_put_nbi():
    pass
    

def _lower__Z27nvshmemx_qp_ptrdiff_put_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_ptrdiff_put_nbi_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ptrdiff_put_nbi(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_ptrdiff_put_nbi_nbst = declare_device(
        '_Z27nvshmemx_qp_ptrdiff_put_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_ptrdiff_put_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z27nvshmemx_qp_ptrdiff_put_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ptrdiff_put_nbi, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_ptrdiff_put_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_ptrdiff_put_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_ptrdiff_put_nbi_nbst(shim_stream, shim_obj)


def qp_ptrdiff_put_nbi_warp():
    pass
    

def _lower__Z32nvshmemx_qp_ptrdiff_put_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_ptrdiff_put_nbi_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ptrdiff_put_nbi_warp(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_ptrdiff_put_nbi_warp_nbst = declare_device(
        '_Z32nvshmemx_qp_ptrdiff_put_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_ptrdiff_put_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z32nvshmemx_qp_ptrdiff_put_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ptrdiff_put_nbi_warp, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_ptrdiff_put_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_ptrdiff_put_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_ptrdiff_put_nbi_warp_nbst(shim_stream, shim_obj)


def qp_ptrdiff_put_nbi_block():
    pass
    

def _lower__Z33nvshmemx_qp_ptrdiff_put_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_ptrdiff_put_nbi_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, int* pe, int* qp_index) {
        nvshmemx_qp_ptrdiff_put_nbi_block(*dest, *source, *nelems, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_ptrdiff_put_nbi_block_nbst = declare_device(
        '_Z33nvshmemx_qp_ptrdiff_put_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_ptrdiff_put_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z33nvshmemx_qp_ptrdiff_put_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_ptrdiff_put_nbi_block, CPointer(int64), CPointer(int64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_ptrdiff_put_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_ptrdiff_put_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_ptrdiff_put_nbi_block_nbst(shim_stream, shim_obj)


def qp_bfloat16_p():
    pass
    

def _lower__Z22nvshmemx_qp_bfloat16_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_qp_bfloat16_p_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16* value, int* pe, int* qp_index) {
        nvshmemx_qp_bfloat16_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z22nvshmemx_qp_bfloat16_p_nbst = declare_device(
        '_Z22nvshmemx_qp_bfloat16_p_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(bfloat16), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_qp_bfloat16_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmemx_qp_bfloat16_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_bfloat16_p, CPointer(bfloat16), bfloat16, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_qp_bfloat16_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_qp_bfloat16_p_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(bfloat16), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_qp_bfloat16_p_nbst(shim_stream, shim_obj)


def qp_half_p():
    pass
    

def _lower__Z18nvshmemx_qp_half_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmemx_qp_half_p_nbst(int &retval , __half ** dest, __half* value, int* pe, int* qp_index) {
        nvshmemx_qp_half_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z18nvshmemx_qp_half_p_nbst = declare_device(
        '_Z18nvshmemx_qp_half_p_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(float16), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z18nvshmemx_qp_half_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmemx_qp_half_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_half_p, CPointer(float16), float16, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmemx_qp_half_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmemx_qp_half_p_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(float16), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmemx_qp_half_p_nbst(shim_stream, shim_obj)


def qp_float_p():
    pass
    

def _lower__Z19nvshmemx_qp_float_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_float_p_nbst(int &retval , float ** dest, float* value, int* pe, int* qp_index) {
        nvshmemx_qp_float_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_float_p_nbst = declare_device(
        '_Z19nvshmemx_qp_float_p_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(float32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_float_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmemx_qp_float_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_float_p, CPointer(float32), float32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_float_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_float_p_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(float32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_float_p_nbst(shim_stream, shim_obj)


def qp_double_p():
    pass
    

def _lower__Z20nvshmemx_qp_double_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_double_p_nbst(int &retval , double ** dest, double* value, int* pe, int* qp_index) {
        nvshmemx_qp_double_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_double_p_nbst = declare_device(
        '_Z20nvshmemx_qp_double_p_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(float64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_double_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmemx_qp_double_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_double_p, CPointer(float64), float64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_double_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_double_p_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(float64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_double_p_nbst(shim_stream, shim_obj)


def qp_char_p():
    pass
    

def _lower__Z18nvshmemx_qp_char_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmemx_qp_char_p_nbst(int &retval , char ** dest, char* value, int* pe, int* qp_index) {
        nvshmemx_qp_char_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z18nvshmemx_qp_char_p_nbst = declare_device(
        '_Z18nvshmemx_qp_char_p_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(int8), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z18nvshmemx_qp_char_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmemx_qp_char_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_char_p, CPointer(int8), int8, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmemx_qp_char_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmemx_qp_char_p_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(int8), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmemx_qp_char_p_nbst(shim_stream, shim_obj)


def qp_short_p():
    pass
    

def _lower__Z19nvshmemx_qp_short_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_short_p_nbst(int &retval , short ** dest, short* value, int* pe, int* qp_index) {
        nvshmemx_qp_short_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_short_p_nbst = declare_device(
        '_Z19nvshmemx_qp_short_p_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(int16), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_short_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmemx_qp_short_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_short_p, CPointer(int16), int16, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_short_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_short_p_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(int16), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_short_p_nbst(shim_stream, shim_obj)


def qp_schar_p():
    pass
    

def _lower__Z19nvshmemx_qp_schar_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_schar_p_nbst(int &retval , signed char ** dest, signed char* value, int* pe, int* qp_index) {
        nvshmemx_qp_schar_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_schar_p_nbst = declare_device(
        '_Z19nvshmemx_qp_schar_p_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(int8), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_schar_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmemx_qp_schar_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_schar_p, CPointer(int8), int8, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_schar_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_schar_p_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(int8), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_schar_p_nbst(shim_stream, shim_obj)


def qp_int_p():
    pass
    

def _lower__Z17nvshmemx_qp_int_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmemx_qp_int_p_nbst(int &retval , int ** dest, int* value, int* pe, int* qp_index) {
        nvshmemx_qp_int_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z17nvshmemx_qp_int_p_nbst = declare_device(
        '_Z17nvshmemx_qp_int_p_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z17nvshmemx_qp_int_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z17nvshmemx_qp_int_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_int_p, CPointer(int32), int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmemx_qp_int_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmemx_qp_int_p_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmemx_qp_int_p_nbst(shim_stream, shim_obj)


def qp_long_p():
    pass
    

def _lower__Z18nvshmemx_qp_long_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmemx_qp_long_p_nbst(int &retval , long ** dest, long* value, int* pe, int* qp_index) {
        nvshmemx_qp_long_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z18nvshmemx_qp_long_p_nbst = declare_device(
        '_Z18nvshmemx_qp_long_p_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z18nvshmemx_qp_long_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmemx_qp_long_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_long_p, CPointer(int64), int64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmemx_qp_long_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmemx_qp_long_p_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmemx_qp_long_p_nbst(shim_stream, shim_obj)


def qp_longlong_p():
    pass
    

def _lower__Z22nvshmemx_qp_longlong_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_qp_longlong_p_nbst(int &retval , long long ** dest, long long* value, int* pe, int* qp_index) {
        nvshmemx_qp_longlong_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z22nvshmemx_qp_longlong_p_nbst = declare_device(
        '_Z22nvshmemx_qp_longlong_p_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_qp_longlong_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z22nvshmemx_qp_longlong_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_longlong_p, CPointer(int64), int64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_qp_longlong_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_qp_longlong_p_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_qp_longlong_p_nbst(shim_stream, shim_obj)


def qp_uchar_p():
    pass
    

def _lower__Z19nvshmemx_qp_uchar_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_uchar_p_nbst(int &retval , unsigned char ** dest, unsigned char* value, int* pe, int* qp_index) {
        nvshmemx_qp_uchar_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_uchar_p_nbst = declare_device(
        '_Z19nvshmemx_qp_uchar_p_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(uint8), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_uchar_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmemx_qp_uchar_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_uchar_p, CPointer(uint8), uint8, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_uchar_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_uchar_p_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(uint8), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_uchar_p_nbst(shim_stream, shim_obj)


def qp_ushort_p():
    pass
    

def _lower__Z20nvshmemx_qp_ushort_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_ushort_p_nbst(int &retval , unsigned short ** dest, unsigned short* value, int* pe, int* qp_index) {
        nvshmemx_qp_ushort_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_ushort_p_nbst = declare_device(
        '_Z20nvshmemx_qp_ushort_p_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(uint16), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_ushort_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmemx_qp_ushort_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_ushort_p, CPointer(uint16), uint16, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_ushort_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_ushort_p_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(uint16), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_ushort_p_nbst(shim_stream, shim_obj)


def qp_uint_p():
    pass
    

def _lower__Z18nvshmemx_qp_uint_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmemx_qp_uint_p_nbst(int &retval , unsigned int ** dest, unsigned int* value, int* pe, int* qp_index) {
        nvshmemx_qp_uint_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z18nvshmemx_qp_uint_p_nbst = declare_device(
        '_Z18nvshmemx_qp_uint_p_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z18nvshmemx_qp_uint_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmemx_qp_uint_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_uint_p, CPointer(uint32), uint32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmemx_qp_uint_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmemx_qp_uint_p_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmemx_qp_uint_p_nbst(shim_stream, shim_obj)


def qp_ulong_p():
    pass
    

def _lower__Z19nvshmemx_qp_ulong_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_ulong_p_nbst(int &retval , unsigned long ** dest, unsigned long* value, int* pe, int* qp_index) {
        nvshmemx_qp_ulong_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_ulong_p_nbst = declare_device(
        '_Z19nvshmemx_qp_ulong_p_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_ulong_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmemx_qp_ulong_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_ulong_p, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_ulong_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_ulong_p_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_ulong_p_nbst(shim_stream, shim_obj)


def qp_ulonglong_p():
    pass
    

def _lower__Z23nvshmemx_qp_ulonglong_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_qp_ulonglong_p_nbst(int &retval , unsigned long long ** dest, unsigned long long* value, int* pe, int* qp_index) {
        nvshmemx_qp_ulonglong_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z23nvshmemx_qp_ulonglong_p_nbst = declare_device(
        '_Z23nvshmemx_qp_ulonglong_p_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_qp_ulonglong_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z23nvshmemx_qp_ulonglong_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_ulonglong_p, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_qp_ulonglong_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_qp_ulonglong_p_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_qp_ulonglong_p_nbst(shim_stream, shim_obj)


def qp_int8_p():
    pass
    

def _lower__Z18nvshmemx_qp_int8_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmemx_qp_int8_p_nbst(int &retval , int8_t ** dest, int8_t* value, int* pe, int* qp_index) {
        nvshmemx_qp_int8_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z18nvshmemx_qp_int8_p_nbst = declare_device(
        '_Z18nvshmemx_qp_int8_p_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(int8), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z18nvshmemx_qp_int8_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmemx_qp_int8_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_int8_p, CPointer(int8), int8, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmemx_qp_int8_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmemx_qp_int8_p_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(int8), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmemx_qp_int8_p_nbst(shim_stream, shim_obj)


def qp_int16_p():
    pass
    

def _lower__Z19nvshmemx_qp_int16_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_int16_p_nbst(int &retval , int16_t ** dest, int16_t* value, int* pe, int* qp_index) {
        nvshmemx_qp_int16_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_int16_p_nbst = declare_device(
        '_Z19nvshmemx_qp_int16_p_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(int16), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_int16_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmemx_qp_int16_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_int16_p, CPointer(int16), int16, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_int16_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_int16_p_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(int16), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_int16_p_nbst(shim_stream, shim_obj)


def qp_int32_p():
    pass
    

def _lower__Z19nvshmemx_qp_int32_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_int32_p_nbst(int &retval , int32_t ** dest, int32_t* value, int* pe, int* qp_index) {
        nvshmemx_qp_int32_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_int32_p_nbst = declare_device(
        '_Z19nvshmemx_qp_int32_p_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_int32_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmemx_qp_int32_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_int32_p, CPointer(int32), int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_int32_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_int32_p_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_int32_p_nbst(shim_stream, shim_obj)


def qp_int64_p():
    pass
    

def _lower__Z19nvshmemx_qp_int64_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_int64_p_nbst(int &retval , int64_t ** dest, int64_t* value, int* pe, int* qp_index) {
        nvshmemx_qp_int64_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_int64_p_nbst = declare_device(
        '_Z19nvshmemx_qp_int64_p_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_int64_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmemx_qp_int64_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_int64_p, CPointer(int64), int64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_int64_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_int64_p_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_int64_p_nbst(shim_stream, shim_obj)


def qp_uint8_p():
    pass
    

def _lower__Z19nvshmemx_qp_uint8_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_uint8_p_nbst(int &retval , uint8_t ** dest, uint8_t* value, int* pe, int* qp_index) {
        nvshmemx_qp_uint8_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_uint8_p_nbst = declare_device(
        '_Z19nvshmemx_qp_uint8_p_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(uint8), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_uint8_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z19nvshmemx_qp_uint8_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_uint8_p, CPointer(uint8), uint8, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_uint8_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_uint8_p_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(uint8), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_uint8_p_nbst(shim_stream, shim_obj)


def qp_uint16_p():
    pass
    

def _lower__Z20nvshmemx_qp_uint16_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_uint16_p_nbst(int &retval , uint16_t ** dest, uint16_t* value, int* pe, int* qp_index) {
        nvshmemx_qp_uint16_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_uint16_p_nbst = declare_device(
        '_Z20nvshmemx_qp_uint16_p_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(uint16), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_uint16_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmemx_qp_uint16_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_uint16_p, CPointer(uint16), uint16, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_uint16_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_uint16_p_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(uint16), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_uint16_p_nbst(shim_stream, shim_obj)


def qp_uint32_p():
    pass
    

def _lower__Z20nvshmemx_qp_uint32_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_uint32_p_nbst(int &retval , uint32_t ** dest, uint32_t* value, int* pe, int* qp_index) {
        nvshmemx_qp_uint32_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_uint32_p_nbst = declare_device(
        '_Z20nvshmemx_qp_uint32_p_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_uint32_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmemx_qp_uint32_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_uint32_p, CPointer(uint32), uint32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_uint32_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_uint32_p_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(uint32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_uint32_p_nbst(shim_stream, shim_obj)


def qp_uint64_p():
    pass
    

def _lower__Z20nvshmemx_qp_uint64_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_uint64_p_nbst(int &retval , uint64_t ** dest, uint64_t* value, int* pe, int* qp_index) {
        nvshmemx_qp_uint64_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_uint64_p_nbst = declare_device(
        '_Z20nvshmemx_qp_uint64_p_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_uint64_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z20nvshmemx_qp_uint64_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_uint64_p, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_uint64_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_uint64_p_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_uint64_p_nbst(shim_stream, shim_obj)


def qp_size_p():
    pass
    

def _lower__Z18nvshmemx_qp_size_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmemx_qp_size_p_nbst(int &retval , unsigned long ** dest, unsigned long* value, int* pe, int* qp_index) {
        nvshmemx_qp_size_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z18nvshmemx_qp_size_p_nbst = declare_device(
        '_Z18nvshmemx_qp_size_p_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z18nvshmemx_qp_size_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z18nvshmemx_qp_size_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_size_p, CPointer(uint64), uint64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmemx_qp_size_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmemx_qp_size_p_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmemx_qp_size_p_nbst(shim_stream, shim_obj)


def qp_ptrdiff_p():
    pass
    

def _lower__Z21nvshmemx_qp_ptrdiff_p_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_ptrdiff_p_nbst(int &retval , long ** dest, long* value, int* pe, int* qp_index) {
        nvshmemx_qp_ptrdiff_p(*dest, *value, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_ptrdiff_p_nbst = declare_device(
        '_Z21nvshmemx_qp_ptrdiff_p_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(int64), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_ptrdiff_p_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _Z21nvshmemx_qp_ptrdiff_p_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(qp_ptrdiff_p, CPointer(int64), int64, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_ptrdiff_p_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_ptrdiff_p_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(int64), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_ptrdiff_p_nbst(shim_stream, shim_obj)


def qp_bfloat16_g():
    pass
    

def _lower__Z22nvshmemx_qp_bfloat16_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_qp_bfloat16_g_nbst(__nv_bfloat16 &retval , __nv_bfloat16 ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_bfloat16_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z22nvshmemx_qp_bfloat16_g_nbst = declare_device(
        '_Z22nvshmemx_qp_bfloat16_g_nbst',
        bfloat16(
            CPointer(CPointer(bfloat16)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_qp_bfloat16_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z22nvshmemx_qp_bfloat16_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_bfloat16_g, CPointer(bfloat16), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_qp_bfloat16_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_qp_bfloat16_g_nbst_caller,
            signature(bfloat16, CPointer(CPointer(bfloat16)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_qp_bfloat16_g_nbst(shim_stream, shim_obj)


def qp_half_g():
    pass
    

def _lower__Z18nvshmemx_qp_half_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmemx_qp_half_g_nbst(__half &retval , __half ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_half_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z18nvshmemx_qp_half_g_nbst = declare_device(
        '_Z18nvshmemx_qp_half_g_nbst',
        float16(
            CPointer(CPointer(float16)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z18nvshmemx_qp_half_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z18nvshmemx_qp_half_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_half_g, CPointer(float16), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmemx_qp_half_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmemx_qp_half_g_nbst_caller,
            signature(float16, CPointer(CPointer(float16)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmemx_qp_half_g_nbst(shim_stream, shim_obj)


def qp_float_g():
    pass
    

def _lower__Z19nvshmemx_qp_float_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_float_g_nbst(float &retval , float ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_float_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_float_g_nbst = declare_device(
        '_Z19nvshmemx_qp_float_g_nbst',
        float32(
            CPointer(CPointer(float32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_float_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z19nvshmemx_qp_float_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_float_g, CPointer(float32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_float_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_float_g_nbst_caller,
            signature(float32, CPointer(CPointer(float32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_float_g_nbst(shim_stream, shim_obj)


def qp_double_g():
    pass
    

def _lower__Z20nvshmemx_qp_double_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_double_g_nbst(double &retval , double ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_double_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_double_g_nbst = declare_device(
        '_Z20nvshmemx_qp_double_g_nbst',
        float64(
            CPointer(CPointer(float64)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_double_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z20nvshmemx_qp_double_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_double_g, CPointer(float64), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_double_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_double_g_nbst_caller,
            signature(float64, CPointer(CPointer(float64)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_double_g_nbst(shim_stream, shim_obj)


def qp_char_g():
    pass
    

def _lower__Z18nvshmemx_qp_char_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmemx_qp_char_g_nbst(char &retval , char ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_char_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z18nvshmemx_qp_char_g_nbst = declare_device(
        '_Z18nvshmemx_qp_char_g_nbst',
        int8(
            CPointer(CPointer(int8)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z18nvshmemx_qp_char_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z18nvshmemx_qp_char_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_char_g, CPointer(int8), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmemx_qp_char_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmemx_qp_char_g_nbst_caller,
            signature(int8, CPointer(CPointer(int8)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmemx_qp_char_g_nbst(shim_stream, shim_obj)


def qp_short_g():
    pass
    

def _lower__Z19nvshmemx_qp_short_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_short_g_nbst(short &retval , short ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_short_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_short_g_nbst = declare_device(
        '_Z19nvshmemx_qp_short_g_nbst',
        int16(
            CPointer(CPointer(int16)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_short_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z19nvshmemx_qp_short_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_short_g, CPointer(int16), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_short_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_short_g_nbst_caller,
            signature(int16, CPointer(CPointer(int16)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_short_g_nbst(shim_stream, shim_obj)


def qp_schar_g():
    pass
    

def _lower__Z19nvshmemx_qp_schar_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_schar_g_nbst(signed char &retval , signed char ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_schar_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_schar_g_nbst = declare_device(
        '_Z19nvshmemx_qp_schar_g_nbst',
        int8(
            CPointer(CPointer(int8)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_schar_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z19nvshmemx_qp_schar_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_schar_g, CPointer(int8), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_schar_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_schar_g_nbst_caller,
            signature(int8, CPointer(CPointer(int8)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_schar_g_nbst(shim_stream, shim_obj)


def qp_int_g():
    pass
    

def _lower__Z17nvshmemx_qp_int_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmemx_qp_int_g_nbst(int &retval , int ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_int_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z17nvshmemx_qp_int_g_nbst = declare_device(
        '_Z17nvshmemx_qp_int_g_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z17nvshmemx_qp_int_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z17nvshmemx_qp_int_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_int_g, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmemx_qp_int_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmemx_qp_int_g_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmemx_qp_int_g_nbst(shim_stream, shim_obj)


def qp_long_g():
    pass
    

def _lower__Z18nvshmemx_qp_long_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmemx_qp_long_g_nbst(long &retval , long ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_long_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z18nvshmemx_qp_long_g_nbst = declare_device(
        '_Z18nvshmemx_qp_long_g_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z18nvshmemx_qp_long_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z18nvshmemx_qp_long_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_long_g, CPointer(int64), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmemx_qp_long_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmemx_qp_long_g_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmemx_qp_long_g_nbst(shim_stream, shim_obj)


def qp_longlong_g():
    pass
    

def _lower__Z22nvshmemx_qp_longlong_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_qp_longlong_g_nbst(long long &retval , long long ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_longlong_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z22nvshmemx_qp_longlong_g_nbst = declare_device(
        '_Z22nvshmemx_qp_longlong_g_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_qp_longlong_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z22nvshmemx_qp_longlong_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_longlong_g, CPointer(int64), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_qp_longlong_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_qp_longlong_g_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_qp_longlong_g_nbst(shim_stream, shim_obj)


def qp_uchar_g():
    pass
    

def _lower__Z19nvshmemx_qp_uchar_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_uchar_g_nbst(unsigned char &retval , unsigned char ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_uchar_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_uchar_g_nbst = declare_device(
        '_Z19nvshmemx_qp_uchar_g_nbst',
        uint8(
            CPointer(CPointer(uint8)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_uchar_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z19nvshmemx_qp_uchar_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_uchar_g, CPointer(uint8), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_uchar_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_uchar_g_nbst_caller,
            signature(uint8, CPointer(CPointer(uint8)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_uchar_g_nbst(shim_stream, shim_obj)


def qp_ushort_g():
    pass
    

def _lower__Z20nvshmemx_qp_ushort_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_ushort_g_nbst(unsigned short &retval , unsigned short ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_ushort_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_ushort_g_nbst = declare_device(
        '_Z20nvshmemx_qp_ushort_g_nbst',
        uint16(
            CPointer(CPointer(uint16)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_ushort_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z20nvshmemx_qp_ushort_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_ushort_g, CPointer(uint16), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_ushort_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_ushort_g_nbst_caller,
            signature(uint16, CPointer(CPointer(uint16)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_ushort_g_nbst(shim_stream, shim_obj)


def qp_uint_g():
    pass
    

def _lower__Z18nvshmemx_qp_uint_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmemx_qp_uint_g_nbst(unsigned int &retval , unsigned int ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_uint_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z18nvshmemx_qp_uint_g_nbst = declare_device(
        '_Z18nvshmemx_qp_uint_g_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z18nvshmemx_qp_uint_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z18nvshmemx_qp_uint_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_uint_g, CPointer(uint32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmemx_qp_uint_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmemx_qp_uint_g_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmemx_qp_uint_g_nbst(shim_stream, shim_obj)


def qp_ulong_g():
    pass
    

def _lower__Z19nvshmemx_qp_ulong_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_ulong_g_nbst(unsigned long &retval , unsigned long ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_ulong_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_ulong_g_nbst = declare_device(
        '_Z19nvshmemx_qp_ulong_g_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_ulong_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z19nvshmemx_qp_ulong_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_ulong_g, CPointer(uint64), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_ulong_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_ulong_g_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_ulong_g_nbst(shim_stream, shim_obj)


def qp_ulonglong_g():
    pass
    

def _lower__Z23nvshmemx_qp_ulonglong_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_qp_ulonglong_g_nbst(unsigned long long &retval , unsigned long long ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_ulonglong_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z23nvshmemx_qp_ulonglong_g_nbst = declare_device(
        '_Z23nvshmemx_qp_ulonglong_g_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_qp_ulonglong_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z23nvshmemx_qp_ulonglong_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_ulonglong_g, CPointer(uint64), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_qp_ulonglong_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_qp_ulonglong_g_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_qp_ulonglong_g_nbst(shim_stream, shim_obj)


def qp_int8_g():
    pass
    

def _lower__Z18nvshmemx_qp_int8_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmemx_qp_int8_g_nbst(int8_t &retval , int8_t ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_int8_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z18nvshmemx_qp_int8_g_nbst = declare_device(
        '_Z18nvshmemx_qp_int8_g_nbst',
        int8(
            CPointer(CPointer(int8)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z18nvshmemx_qp_int8_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z18nvshmemx_qp_int8_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_int8_g, CPointer(int8), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmemx_qp_int8_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmemx_qp_int8_g_nbst_caller,
            signature(int8, CPointer(CPointer(int8)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmemx_qp_int8_g_nbst(shim_stream, shim_obj)


def qp_int16_g():
    pass
    

def _lower__Z19nvshmemx_qp_int16_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_int16_g_nbst(int16_t &retval , int16_t ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_int16_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_int16_g_nbst = declare_device(
        '_Z19nvshmemx_qp_int16_g_nbst',
        int16(
            CPointer(CPointer(int16)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_int16_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z19nvshmemx_qp_int16_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_int16_g, CPointer(int16), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_int16_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_int16_g_nbst_caller,
            signature(int16, CPointer(CPointer(int16)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_int16_g_nbst(shim_stream, shim_obj)


def qp_int32_g():
    pass
    

def _lower__Z19nvshmemx_qp_int32_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_int32_g_nbst(int32_t &retval , int32_t ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_int32_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_int32_g_nbst = declare_device(
        '_Z19nvshmemx_qp_int32_g_nbst',
        int32(
            CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_int32_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z19nvshmemx_qp_int32_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_int32_g, CPointer(int32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_int32_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_int32_g_nbst_caller,
            signature(int32, CPointer(CPointer(int32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_int32_g_nbst(shim_stream, shim_obj)


def qp_int64_g():
    pass
    

def _lower__Z19nvshmemx_qp_int64_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_int64_g_nbst(int64_t &retval , int64_t ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_int64_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_int64_g_nbst = declare_device(
        '_Z19nvshmemx_qp_int64_g_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_int64_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z19nvshmemx_qp_int64_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_int64_g, CPointer(int64), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_int64_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_int64_g_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_int64_g_nbst(shim_stream, shim_obj)


def qp_uint8_g():
    pass
    

def _lower__Z19nvshmemx_qp_uint8_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z19nvshmemx_qp_uint8_g_nbst(uint8_t &retval , uint8_t ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_uint8_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z19nvshmemx_qp_uint8_g_nbst = declare_device(
        '_Z19nvshmemx_qp_uint8_g_nbst',
        uint8(
            CPointer(CPointer(uint8)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z19nvshmemx_qp_uint8_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z19nvshmemx_qp_uint8_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_uint8_g, CPointer(uint8), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z19nvshmemx_qp_uint8_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z19nvshmemx_qp_uint8_g_nbst_caller,
            signature(uint8, CPointer(CPointer(uint8)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z19nvshmemx_qp_uint8_g_nbst(shim_stream, shim_obj)


def qp_uint16_g():
    pass
    

def _lower__Z20nvshmemx_qp_uint16_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_uint16_g_nbst(uint16_t &retval , uint16_t ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_uint16_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_uint16_g_nbst = declare_device(
        '_Z20nvshmemx_qp_uint16_g_nbst',
        uint16(
            CPointer(CPointer(uint16)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_uint16_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z20nvshmemx_qp_uint16_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_uint16_g, CPointer(uint16), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_uint16_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_uint16_g_nbst_caller,
            signature(uint16, CPointer(CPointer(uint16)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_uint16_g_nbst(shim_stream, shim_obj)


def qp_uint32_g():
    pass
    

def _lower__Z20nvshmemx_qp_uint32_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_uint32_g_nbst(uint32_t &retval , uint32_t ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_uint32_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_uint32_g_nbst = declare_device(
        '_Z20nvshmemx_qp_uint32_g_nbst',
        uint32(
            CPointer(CPointer(uint32)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_uint32_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z20nvshmemx_qp_uint32_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_uint32_g, CPointer(uint32), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_uint32_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_uint32_g_nbst_caller,
            signature(uint32, CPointer(CPointer(uint32)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_uint32_g_nbst(shim_stream, shim_obj)


def qp_uint64_g():
    pass
    

def _lower__Z20nvshmemx_qp_uint64_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z20nvshmemx_qp_uint64_g_nbst(uint64_t &retval , uint64_t ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_uint64_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z20nvshmemx_qp_uint64_g_nbst = declare_device(
        '_Z20nvshmemx_qp_uint64_g_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z20nvshmemx_qp_uint64_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z20nvshmemx_qp_uint64_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_uint64_g, CPointer(uint64), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z20nvshmemx_qp_uint64_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z20nvshmemx_qp_uint64_g_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z20nvshmemx_qp_uint64_g_nbst(shim_stream, shim_obj)


def qp_size_g():
    pass
    

def _lower__Z18nvshmemx_qp_size_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z18nvshmemx_qp_size_g_nbst(unsigned long &retval , unsigned long ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_size_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z18nvshmemx_qp_size_g_nbst = declare_device(
        '_Z18nvshmemx_qp_size_g_nbst',
        uint64(
            CPointer(CPointer(uint64)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z18nvshmemx_qp_size_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z18nvshmemx_qp_size_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_size_g, CPointer(uint64), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z18nvshmemx_qp_size_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z18nvshmemx_qp_size_g_nbst_caller,
            signature(uint64, CPointer(CPointer(uint64)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z18nvshmemx_qp_size_g_nbst(shim_stream, shim_obj)


def qp_ptrdiff_g():
    pass
    

def _lower__Z21nvshmemx_qp_ptrdiff_g_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_ptrdiff_g_nbst(long &retval , long ** source, int* pe, int* qp_index) {
        retval = nvshmemx_qp_ptrdiff_g(*source, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_ptrdiff_g_nbst = declare_device(
        '_Z21nvshmemx_qp_ptrdiff_g_nbst',
        int64(
            CPointer(CPointer(int64)), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_ptrdiff_g_nbst_caller(arg_0, arg_1, arg_2):
        return _Z21nvshmemx_qp_ptrdiff_g_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_ptrdiff_g, CPointer(int64), int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_ptrdiff_g_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_ptrdiff_g_nbst_caller,
            signature(int64, CPointer(CPointer(int64)), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_ptrdiff_g_nbst(shim_stream, shim_obj)


def qp_signal_op():
    pass
    

def _lower__Z21nvshmemx_qp_signal_op_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z21nvshmemx_qp_signal_op_nbst(int &retval , uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_signal_op(*sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z21nvshmemx_qp_signal_op_nbst = declare_device(
        '_Z21nvshmemx_qp_signal_op_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z21nvshmemx_qp_signal_op_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _Z21nvshmemx_qp_signal_op_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(qp_signal_op, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z21nvshmemx_qp_signal_op_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z21nvshmemx_qp_signal_op_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z21nvshmemx_qp_signal_op_nbst(shim_stream, shim_obj)


def qp_bfloat16_put_signal():
    pass
    

def _lower__Z31nvshmemx_qp_bfloat16_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_bfloat16_put_signal_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_bfloat16_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_bfloat16_put_signal_nbst = declare_device(
        '_Z31nvshmemx_qp_bfloat16_put_signal_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_bfloat16_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemx_qp_bfloat16_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_bfloat16_put_signal, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_bfloat16_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_bfloat16_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_bfloat16_put_signal_nbst(shim_stream, shim_obj)


def qp_bfloat16_put_signal_warp():
    pass
    

def _lower__Z36nvshmemx_qp_bfloat16_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmemx_qp_bfloat16_put_signal_warp_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_bfloat16_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z36nvshmemx_qp_bfloat16_put_signal_warp_nbst = declare_device(
        '_Z36nvshmemx_qp_bfloat16_put_signal_warp_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z36nvshmemx_qp_bfloat16_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z36nvshmemx_qp_bfloat16_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_bfloat16_put_signal_warp, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z36nvshmemx_qp_bfloat16_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmemx_qp_bfloat16_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z36nvshmemx_qp_bfloat16_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_bfloat16_put_signal_block():
    pass
    

def _lower__Z37nvshmemx_qp_bfloat16_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_qp_bfloat16_put_signal_block_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_bfloat16_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z37nvshmemx_qp_bfloat16_put_signal_block_nbst = declare_device(
        '_Z37nvshmemx_qp_bfloat16_put_signal_block_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_qp_bfloat16_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z37nvshmemx_qp_bfloat16_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_bfloat16_put_signal_block, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_qp_bfloat16_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_qp_bfloat16_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_qp_bfloat16_put_signal_block_nbst(shim_stream, shim_obj)


def qp_half_put_signal():
    pass
    

def _lower__Z27nvshmemx_qp_half_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_half_put_signal_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_half_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_half_put_signal_nbst = declare_device(
        '_Z27nvshmemx_qp_half_put_signal_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_half_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z27nvshmemx_qp_half_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_half_put_signal, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_half_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_half_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_half_put_signal_nbst(shim_stream, shim_obj)


def qp_half_put_signal_warp():
    pass
    

def _lower__Z32nvshmemx_qp_half_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_half_put_signal_warp_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_half_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_half_put_signal_warp_nbst = declare_device(
        '_Z32nvshmemx_qp_half_put_signal_warp_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_half_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemx_qp_half_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_half_put_signal_warp, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_half_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_half_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_half_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_half_put_signal_block():
    pass
    

def _lower__Z33nvshmemx_qp_half_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_half_put_signal_block_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_half_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_half_put_signal_block_nbst = declare_device(
        '_Z33nvshmemx_qp_half_put_signal_block_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_half_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_half_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_half_put_signal_block, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_half_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_half_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_half_put_signal_block_nbst(shim_stream, shim_obj)


def qp_float_put_signal():
    pass
    

def _lower__Z28nvshmemx_qp_float_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_float_put_signal_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_float_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_float_put_signal_nbst = declare_device(
        '_Z28nvshmemx_qp_float_put_signal_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_float_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z28nvshmemx_qp_float_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_float_put_signal, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_float_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_float_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_float_put_signal_nbst(shim_stream, shim_obj)


def qp_float_put_signal_warp():
    pass
    

def _lower__Z33nvshmemx_qp_float_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_float_put_signal_warp_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_float_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_float_put_signal_warp_nbst = declare_device(
        '_Z33nvshmemx_qp_float_put_signal_warp_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_float_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_float_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_float_put_signal_warp, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_float_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_float_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_float_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_float_put_signal_block():
    pass
    

def _lower__Z34nvshmemx_qp_float_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_float_put_signal_block_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_float_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_float_put_signal_block_nbst = declare_device(
        '_Z34nvshmemx_qp_float_put_signal_block_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_float_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z34nvshmemx_qp_float_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_float_put_signal_block, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_float_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_float_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_float_put_signal_block_nbst(shim_stream, shim_obj)


def qp_double_put_signal():
    pass
    

def _lower__Z29nvshmemx_qp_double_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_double_put_signal_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_double_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_double_put_signal_nbst = declare_device(
        '_Z29nvshmemx_qp_double_put_signal_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_double_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z29nvshmemx_qp_double_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_double_put_signal, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_double_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_double_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_double_put_signal_nbst(shim_stream, shim_obj)


def qp_double_put_signal_warp():
    pass
    

def _lower__Z34nvshmemx_qp_double_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_double_put_signal_warp_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_double_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_double_put_signal_warp_nbst = declare_device(
        '_Z34nvshmemx_qp_double_put_signal_warp_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_double_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z34nvshmemx_qp_double_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_double_put_signal_warp, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_double_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_double_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_double_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_double_put_signal_block():
    pass
    

def _lower__Z35nvshmemx_qp_double_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_qp_double_put_signal_block_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_double_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z35nvshmemx_qp_double_put_signal_block_nbst = declare_device(
        '_Z35nvshmemx_qp_double_put_signal_block_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_qp_double_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z35nvshmemx_qp_double_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_double_put_signal_block, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_qp_double_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_qp_double_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_qp_double_put_signal_block_nbst(shim_stream, shim_obj)


def qp_char_put_signal():
    pass
    

def _lower__Z27nvshmemx_qp_char_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_char_put_signal_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_char_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_char_put_signal_nbst = declare_device(
        '_Z27nvshmemx_qp_char_put_signal_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_char_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z27nvshmemx_qp_char_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_char_put_signal, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_char_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_char_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_char_put_signal_nbst(shim_stream, shim_obj)


def qp_char_put_signal_warp():
    pass
    

def _lower__Z32nvshmemx_qp_char_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_char_put_signal_warp_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_char_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_char_put_signal_warp_nbst = declare_device(
        '_Z32nvshmemx_qp_char_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_char_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemx_qp_char_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_char_put_signal_warp, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_char_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_char_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_char_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_char_put_signal_block():
    pass
    

def _lower__Z33nvshmemx_qp_char_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_char_put_signal_block_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_char_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_char_put_signal_block_nbst = declare_device(
        '_Z33nvshmemx_qp_char_put_signal_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_char_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_char_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_char_put_signal_block, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_char_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_char_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_char_put_signal_block_nbst(shim_stream, shim_obj)


def qp_short_put_signal():
    pass
    

def _lower__Z28nvshmemx_qp_short_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_short_put_signal_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_short_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_short_put_signal_nbst = declare_device(
        '_Z28nvshmemx_qp_short_put_signal_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_short_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z28nvshmemx_qp_short_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_short_put_signal, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_short_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_short_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_short_put_signal_nbst(shim_stream, shim_obj)


def qp_short_put_signal_warp():
    pass
    

def _lower__Z33nvshmemx_qp_short_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_short_put_signal_warp_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_short_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_short_put_signal_warp_nbst = declare_device(
        '_Z33nvshmemx_qp_short_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_short_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_short_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_short_put_signal_warp, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_short_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_short_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_short_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_short_put_signal_block():
    pass
    

def _lower__Z34nvshmemx_qp_short_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_short_put_signal_block_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_short_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_short_put_signal_block_nbst = declare_device(
        '_Z34nvshmemx_qp_short_put_signal_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_short_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z34nvshmemx_qp_short_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_short_put_signal_block, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_short_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_short_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_short_put_signal_block_nbst(shim_stream, shim_obj)


def qp_schar_put_signal():
    pass
    

def _lower__Z28nvshmemx_qp_schar_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_schar_put_signal_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_schar_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_schar_put_signal_nbst = declare_device(
        '_Z28nvshmemx_qp_schar_put_signal_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_schar_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z28nvshmemx_qp_schar_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_schar_put_signal, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_schar_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_schar_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_schar_put_signal_nbst(shim_stream, shim_obj)


def qp_schar_put_signal_warp():
    pass
    

def _lower__Z33nvshmemx_qp_schar_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_schar_put_signal_warp_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_schar_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_schar_put_signal_warp_nbst = declare_device(
        '_Z33nvshmemx_qp_schar_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_schar_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_schar_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_schar_put_signal_warp, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_schar_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_schar_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_schar_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_schar_put_signal_block():
    pass
    

def _lower__Z34nvshmemx_qp_schar_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_schar_put_signal_block_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_schar_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_schar_put_signal_block_nbst = declare_device(
        '_Z34nvshmemx_qp_schar_put_signal_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_schar_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z34nvshmemx_qp_schar_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_schar_put_signal_block, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_schar_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_schar_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_schar_put_signal_block_nbst(shim_stream, shim_obj)


def qp_int_put_signal():
    pass
    

def _lower__Z26nvshmemx_qp_int_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z26nvshmemx_qp_int_put_signal_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z26nvshmemx_qp_int_put_signal_nbst = declare_device(
        '_Z26nvshmemx_qp_int_put_signal_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z26nvshmemx_qp_int_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z26nvshmemx_qp_int_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int_put_signal, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z26nvshmemx_qp_int_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z26nvshmemx_qp_int_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z26nvshmemx_qp_int_put_signal_nbst(shim_stream, shim_obj)


def qp_int_put_signal_warp():
    pass
    

def _lower__Z31nvshmemx_qp_int_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_int_put_signal_warp_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_int_put_signal_warp_nbst = declare_device(
        '_Z31nvshmemx_qp_int_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_int_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemx_qp_int_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int_put_signal_warp, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_int_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_int_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_int_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_int_put_signal_block():
    pass
    

def _lower__Z32nvshmemx_qp_int_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_int_put_signal_block_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_int_put_signal_block_nbst = declare_device(
        '_Z32nvshmemx_qp_int_put_signal_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_int_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemx_qp_int_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int_put_signal_block, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_int_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_int_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_int_put_signal_block_nbst(shim_stream, shim_obj)


def qp_long_put_signal():
    pass
    

def _lower__Z27nvshmemx_qp_long_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_long_put_signal_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_long_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_long_put_signal_nbst = declare_device(
        '_Z27nvshmemx_qp_long_put_signal_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_long_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z27nvshmemx_qp_long_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_long_put_signal, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_long_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_long_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_long_put_signal_nbst(shim_stream, shim_obj)


def qp_long_put_signal_warp():
    pass
    

def _lower__Z32nvshmemx_qp_long_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_long_put_signal_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_long_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_long_put_signal_warp_nbst = declare_device(
        '_Z32nvshmemx_qp_long_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_long_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemx_qp_long_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_long_put_signal_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_long_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_long_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_long_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_long_put_signal_block():
    pass
    

def _lower__Z33nvshmemx_qp_long_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_long_put_signal_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_long_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_long_put_signal_block_nbst = declare_device(
        '_Z33nvshmemx_qp_long_put_signal_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_long_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_long_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_long_put_signal_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_long_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_long_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_long_put_signal_block_nbst(shim_stream, shim_obj)


def qp_longlong_put_signal():
    pass
    

def _lower__Z31nvshmemx_qp_longlong_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_longlong_put_signal_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_longlong_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_longlong_put_signal_nbst = declare_device(
        '_Z31nvshmemx_qp_longlong_put_signal_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_longlong_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemx_qp_longlong_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_longlong_put_signal, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_longlong_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_longlong_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_longlong_put_signal_nbst(shim_stream, shim_obj)


def qp_longlong_put_signal_warp():
    pass
    

def _lower__Z36nvshmemx_qp_longlong_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmemx_qp_longlong_put_signal_warp_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_longlong_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z36nvshmemx_qp_longlong_put_signal_warp_nbst = declare_device(
        '_Z36nvshmemx_qp_longlong_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z36nvshmemx_qp_longlong_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z36nvshmemx_qp_longlong_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_longlong_put_signal_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z36nvshmemx_qp_longlong_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmemx_qp_longlong_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z36nvshmemx_qp_longlong_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_longlong_put_signal_block():
    pass
    

def _lower__Z37nvshmemx_qp_longlong_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_qp_longlong_put_signal_block_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_longlong_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z37nvshmemx_qp_longlong_put_signal_block_nbst = declare_device(
        '_Z37nvshmemx_qp_longlong_put_signal_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_qp_longlong_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z37nvshmemx_qp_longlong_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_longlong_put_signal_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_qp_longlong_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_qp_longlong_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_qp_longlong_put_signal_block_nbst(shim_stream, shim_obj)


def qp_uchar_put_signal():
    pass
    

def _lower__Z28nvshmemx_qp_uchar_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_uchar_put_signal_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uchar_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_uchar_put_signal_nbst = declare_device(
        '_Z28nvshmemx_qp_uchar_put_signal_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_uchar_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z28nvshmemx_qp_uchar_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uchar_put_signal, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_uchar_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_uchar_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_uchar_put_signal_nbst(shim_stream, shim_obj)


def qp_uchar_put_signal_warp():
    pass
    

def _lower__Z33nvshmemx_qp_uchar_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_uchar_put_signal_warp_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uchar_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_uchar_put_signal_warp_nbst = declare_device(
        '_Z33nvshmemx_qp_uchar_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_uchar_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_uchar_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uchar_put_signal_warp, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_uchar_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_uchar_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_uchar_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_uchar_put_signal_block():
    pass
    

def _lower__Z34nvshmemx_qp_uchar_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_uchar_put_signal_block_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uchar_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_uchar_put_signal_block_nbst = declare_device(
        '_Z34nvshmemx_qp_uchar_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_uchar_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z34nvshmemx_qp_uchar_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uchar_put_signal_block, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_uchar_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_uchar_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_uchar_put_signal_block_nbst(shim_stream, shim_obj)


def qp_ushort_put_signal():
    pass
    

def _lower__Z29nvshmemx_qp_ushort_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_ushort_put_signal_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ushort_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_ushort_put_signal_nbst = declare_device(
        '_Z29nvshmemx_qp_ushort_put_signal_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_ushort_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z29nvshmemx_qp_ushort_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ushort_put_signal, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_ushort_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_ushort_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_ushort_put_signal_nbst(shim_stream, shim_obj)


def qp_ushort_put_signal_warp():
    pass
    

def _lower__Z34nvshmemx_qp_ushort_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_ushort_put_signal_warp_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ushort_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_ushort_put_signal_warp_nbst = declare_device(
        '_Z34nvshmemx_qp_ushort_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_ushort_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z34nvshmemx_qp_ushort_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ushort_put_signal_warp, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_ushort_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_ushort_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_ushort_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_ushort_put_signal_block():
    pass
    

def _lower__Z35nvshmemx_qp_ushort_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_qp_ushort_put_signal_block_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ushort_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z35nvshmemx_qp_ushort_put_signal_block_nbst = declare_device(
        '_Z35nvshmemx_qp_ushort_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_qp_ushort_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z35nvshmemx_qp_ushort_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ushort_put_signal_block, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_qp_ushort_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_qp_ushort_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_qp_ushort_put_signal_block_nbst(shim_stream, shim_obj)


def qp_uint_put_signal():
    pass
    

def _lower__Z27nvshmemx_qp_uint_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_uint_put_signal_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_uint_put_signal_nbst = declare_device(
        '_Z27nvshmemx_qp_uint_put_signal_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_uint_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z27nvshmemx_qp_uint_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint_put_signal, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_uint_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_uint_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_uint_put_signal_nbst(shim_stream, shim_obj)


def qp_uint_put_signal_warp():
    pass
    

def _lower__Z32nvshmemx_qp_uint_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_uint_put_signal_warp_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_uint_put_signal_warp_nbst = declare_device(
        '_Z32nvshmemx_qp_uint_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_uint_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemx_qp_uint_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint_put_signal_warp, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_uint_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_uint_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_uint_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_uint_put_signal_block():
    pass
    

def _lower__Z33nvshmemx_qp_uint_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_uint_put_signal_block_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_uint_put_signal_block_nbst = declare_device(
        '_Z33nvshmemx_qp_uint_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_uint_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_uint_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint_put_signal_block, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_uint_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_uint_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_uint_put_signal_block_nbst(shim_stream, shim_obj)


def qp_ulong_put_signal():
    pass
    

def _lower__Z28nvshmemx_qp_ulong_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_ulong_put_signal_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ulong_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_ulong_put_signal_nbst = declare_device(
        '_Z28nvshmemx_qp_ulong_put_signal_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_ulong_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z28nvshmemx_qp_ulong_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ulong_put_signal, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_ulong_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_ulong_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_ulong_put_signal_nbst(shim_stream, shim_obj)


def qp_ulong_put_signal_warp():
    pass
    

def _lower__Z33nvshmemx_qp_ulong_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_ulong_put_signal_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ulong_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_ulong_put_signal_warp_nbst = declare_device(
        '_Z33nvshmemx_qp_ulong_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_ulong_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_ulong_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ulong_put_signal_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_ulong_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_ulong_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_ulong_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_ulong_put_signal_block():
    pass
    

def _lower__Z34nvshmemx_qp_ulong_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_ulong_put_signal_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ulong_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_ulong_put_signal_block_nbst = declare_device(
        '_Z34nvshmemx_qp_ulong_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_ulong_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z34nvshmemx_qp_ulong_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ulong_put_signal_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_ulong_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_ulong_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_ulong_put_signal_block_nbst(shim_stream, shim_obj)


def qp_ulonglong_put_signal():
    pass
    

def _lower__Z32nvshmemx_qp_ulonglong_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_ulonglong_put_signal_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ulonglong_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_ulonglong_put_signal_nbst = declare_device(
        '_Z32nvshmemx_qp_ulonglong_put_signal_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_ulonglong_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemx_qp_ulonglong_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ulonglong_put_signal, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_ulonglong_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_ulonglong_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_ulonglong_put_signal_nbst(shim_stream, shim_obj)


def qp_ulonglong_put_signal_warp():
    pass
    

def _lower__Z37nvshmemx_qp_ulonglong_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_qp_ulonglong_put_signal_warp_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ulonglong_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z37nvshmemx_qp_ulonglong_put_signal_warp_nbst = declare_device(
        '_Z37nvshmemx_qp_ulonglong_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_qp_ulonglong_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z37nvshmemx_qp_ulonglong_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ulonglong_put_signal_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_qp_ulonglong_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_qp_ulonglong_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_qp_ulonglong_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_ulonglong_put_signal_block():
    pass
    

def _lower__Z38nvshmemx_qp_ulonglong_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmemx_qp_ulonglong_put_signal_block_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ulonglong_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z38nvshmemx_qp_ulonglong_put_signal_block_nbst = declare_device(
        '_Z38nvshmemx_qp_ulonglong_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z38nvshmemx_qp_ulonglong_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z38nvshmemx_qp_ulonglong_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ulonglong_put_signal_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z38nvshmemx_qp_ulonglong_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmemx_qp_ulonglong_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z38nvshmemx_qp_ulonglong_put_signal_block_nbst(shim_stream, shim_obj)


def qp_int8_put_signal():
    pass
    

def _lower__Z27nvshmemx_qp_int8_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_int8_put_signal_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int8_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_int8_put_signal_nbst = declare_device(
        '_Z27nvshmemx_qp_int8_put_signal_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_int8_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z27nvshmemx_qp_int8_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int8_put_signal, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_int8_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_int8_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_int8_put_signal_nbst(shim_stream, shim_obj)


def qp_int8_put_signal_warp():
    pass
    

def _lower__Z32nvshmemx_qp_int8_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_int8_put_signal_warp_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int8_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_int8_put_signal_warp_nbst = declare_device(
        '_Z32nvshmemx_qp_int8_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_int8_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemx_qp_int8_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int8_put_signal_warp, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_int8_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_int8_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_int8_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_int8_put_signal_block():
    pass
    

def _lower__Z33nvshmemx_qp_int8_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_int8_put_signal_block_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int8_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_int8_put_signal_block_nbst = declare_device(
        '_Z33nvshmemx_qp_int8_put_signal_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_int8_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_int8_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int8_put_signal_block, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_int8_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_int8_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_int8_put_signal_block_nbst(shim_stream, shim_obj)


def qp_int16_put_signal():
    pass
    

def _lower__Z28nvshmemx_qp_int16_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_int16_put_signal_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int16_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_int16_put_signal_nbst = declare_device(
        '_Z28nvshmemx_qp_int16_put_signal_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_int16_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z28nvshmemx_qp_int16_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int16_put_signal, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_int16_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_int16_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_int16_put_signal_nbst(shim_stream, shim_obj)


def qp_int16_put_signal_warp():
    pass
    

def _lower__Z33nvshmemx_qp_int16_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_int16_put_signal_warp_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int16_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_int16_put_signal_warp_nbst = declare_device(
        '_Z33nvshmemx_qp_int16_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_int16_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_int16_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int16_put_signal_warp, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_int16_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_int16_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_int16_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_int16_put_signal_block():
    pass
    

def _lower__Z34nvshmemx_qp_int16_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_int16_put_signal_block_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int16_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_int16_put_signal_block_nbst = declare_device(
        '_Z34nvshmemx_qp_int16_put_signal_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_int16_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z34nvshmemx_qp_int16_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int16_put_signal_block, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_int16_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_int16_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_int16_put_signal_block_nbst(shim_stream, shim_obj)


def qp_int32_put_signal():
    pass
    

def _lower__Z28nvshmemx_qp_int32_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_int32_put_signal_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int32_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_int32_put_signal_nbst = declare_device(
        '_Z28nvshmemx_qp_int32_put_signal_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_int32_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z28nvshmemx_qp_int32_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int32_put_signal, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_int32_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_int32_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_int32_put_signal_nbst(shim_stream, shim_obj)


def qp_int32_put_signal_warp():
    pass
    

def _lower__Z33nvshmemx_qp_int32_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_int32_put_signal_warp_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int32_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_int32_put_signal_warp_nbst = declare_device(
        '_Z33nvshmemx_qp_int32_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_int32_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_int32_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int32_put_signal_warp, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_int32_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_int32_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_int32_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_int32_put_signal_block():
    pass
    

def _lower__Z34nvshmemx_qp_int32_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_int32_put_signal_block_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int32_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_int32_put_signal_block_nbst = declare_device(
        '_Z34nvshmemx_qp_int32_put_signal_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_int32_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z34nvshmemx_qp_int32_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int32_put_signal_block, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_int32_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_int32_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_int32_put_signal_block_nbst(shim_stream, shim_obj)


def qp_int64_put_signal():
    pass
    

def _lower__Z28nvshmemx_qp_int64_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_int64_put_signal_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int64_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_int64_put_signal_nbst = declare_device(
        '_Z28nvshmemx_qp_int64_put_signal_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_int64_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z28nvshmemx_qp_int64_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int64_put_signal, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_int64_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_int64_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_int64_put_signal_nbst(shim_stream, shim_obj)


def qp_int64_put_signal_warp():
    pass
    

def _lower__Z33nvshmemx_qp_int64_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_int64_put_signal_warp_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int64_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_int64_put_signal_warp_nbst = declare_device(
        '_Z33nvshmemx_qp_int64_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_int64_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_int64_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int64_put_signal_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_int64_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_int64_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_int64_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_int64_put_signal_block():
    pass
    

def _lower__Z34nvshmemx_qp_int64_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_int64_put_signal_block_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int64_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_int64_put_signal_block_nbst = declare_device(
        '_Z34nvshmemx_qp_int64_put_signal_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_int64_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z34nvshmemx_qp_int64_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int64_put_signal_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_int64_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_int64_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_int64_put_signal_block_nbst(shim_stream, shim_obj)


def qp_uint8_put_signal():
    pass
    

def _lower__Z28nvshmemx_qp_uint8_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z28nvshmemx_qp_uint8_put_signal_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint8_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z28nvshmemx_qp_uint8_put_signal_nbst = declare_device(
        '_Z28nvshmemx_qp_uint8_put_signal_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z28nvshmemx_qp_uint8_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z28nvshmemx_qp_uint8_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint8_put_signal, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z28nvshmemx_qp_uint8_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z28nvshmemx_qp_uint8_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z28nvshmemx_qp_uint8_put_signal_nbst(shim_stream, shim_obj)


def qp_uint8_put_signal_warp():
    pass
    

def _lower__Z33nvshmemx_qp_uint8_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_uint8_put_signal_warp_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint8_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_uint8_put_signal_warp_nbst = declare_device(
        '_Z33nvshmemx_qp_uint8_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_uint8_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_uint8_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint8_put_signal_warp, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_uint8_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_uint8_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_uint8_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_uint8_put_signal_block():
    pass
    

def _lower__Z34nvshmemx_qp_uint8_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_uint8_put_signal_block_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint8_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_uint8_put_signal_block_nbst = declare_device(
        '_Z34nvshmemx_qp_uint8_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_uint8_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z34nvshmemx_qp_uint8_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint8_put_signal_block, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_uint8_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_uint8_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_uint8_put_signal_block_nbst(shim_stream, shim_obj)


def qp_uint16_put_signal():
    pass
    

def _lower__Z29nvshmemx_qp_uint16_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_uint16_put_signal_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint16_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_uint16_put_signal_nbst = declare_device(
        '_Z29nvshmemx_qp_uint16_put_signal_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_uint16_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z29nvshmemx_qp_uint16_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint16_put_signal, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_uint16_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_uint16_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_uint16_put_signal_nbst(shim_stream, shim_obj)


def qp_uint16_put_signal_warp():
    pass
    

def _lower__Z34nvshmemx_qp_uint16_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_uint16_put_signal_warp_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint16_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_uint16_put_signal_warp_nbst = declare_device(
        '_Z34nvshmemx_qp_uint16_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_uint16_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z34nvshmemx_qp_uint16_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint16_put_signal_warp, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_uint16_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_uint16_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_uint16_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_uint16_put_signal_block():
    pass
    

def _lower__Z35nvshmemx_qp_uint16_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_qp_uint16_put_signal_block_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint16_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z35nvshmemx_qp_uint16_put_signal_block_nbst = declare_device(
        '_Z35nvshmemx_qp_uint16_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_qp_uint16_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z35nvshmemx_qp_uint16_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint16_put_signal_block, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_qp_uint16_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_qp_uint16_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_qp_uint16_put_signal_block_nbst(shim_stream, shim_obj)


def qp_uint32_put_signal():
    pass
    

def _lower__Z29nvshmemx_qp_uint32_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_uint32_put_signal_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint32_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_uint32_put_signal_nbst = declare_device(
        '_Z29nvshmemx_qp_uint32_put_signal_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_uint32_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z29nvshmemx_qp_uint32_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint32_put_signal, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_uint32_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_uint32_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_uint32_put_signal_nbst(shim_stream, shim_obj)


def qp_uint32_put_signal_warp():
    pass
    

def _lower__Z34nvshmemx_qp_uint32_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_uint32_put_signal_warp_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint32_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_uint32_put_signal_warp_nbst = declare_device(
        '_Z34nvshmemx_qp_uint32_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_uint32_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z34nvshmemx_qp_uint32_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint32_put_signal_warp, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_uint32_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_uint32_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_uint32_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_uint32_put_signal_block():
    pass
    

def _lower__Z35nvshmemx_qp_uint32_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_qp_uint32_put_signal_block_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint32_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z35nvshmemx_qp_uint32_put_signal_block_nbst = declare_device(
        '_Z35nvshmemx_qp_uint32_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_qp_uint32_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z35nvshmemx_qp_uint32_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint32_put_signal_block, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_qp_uint32_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_qp_uint32_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_qp_uint32_put_signal_block_nbst(shim_stream, shim_obj)


def qp_uint64_put_signal():
    pass
    

def _lower__Z29nvshmemx_qp_uint64_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z29nvshmemx_qp_uint64_put_signal_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint64_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z29nvshmemx_qp_uint64_put_signal_nbst = declare_device(
        '_Z29nvshmemx_qp_uint64_put_signal_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z29nvshmemx_qp_uint64_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z29nvshmemx_qp_uint64_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint64_put_signal, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z29nvshmemx_qp_uint64_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z29nvshmemx_qp_uint64_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z29nvshmemx_qp_uint64_put_signal_nbst(shim_stream, shim_obj)


def qp_uint64_put_signal_warp():
    pass
    

def _lower__Z34nvshmemx_qp_uint64_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_uint64_put_signal_warp_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint64_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_uint64_put_signal_warp_nbst = declare_device(
        '_Z34nvshmemx_qp_uint64_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_uint64_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z34nvshmemx_qp_uint64_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint64_put_signal_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_uint64_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_uint64_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_uint64_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_uint64_put_signal_block():
    pass
    

def _lower__Z35nvshmemx_qp_uint64_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_qp_uint64_put_signal_block_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint64_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z35nvshmemx_qp_uint64_put_signal_block_nbst = declare_device(
        '_Z35nvshmemx_qp_uint64_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_qp_uint64_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z35nvshmemx_qp_uint64_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint64_put_signal_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_qp_uint64_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_qp_uint64_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_qp_uint64_put_signal_block_nbst(shim_stream, shim_obj)


def qp_size_put_signal():
    pass
    

def _lower__Z27nvshmemx_qp_size_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z27nvshmemx_qp_size_put_signal_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_size_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z27nvshmemx_qp_size_put_signal_nbst = declare_device(
        '_Z27nvshmemx_qp_size_put_signal_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z27nvshmemx_qp_size_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z27nvshmemx_qp_size_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_size_put_signal, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z27nvshmemx_qp_size_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z27nvshmemx_qp_size_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z27nvshmemx_qp_size_put_signal_nbst(shim_stream, shim_obj)


def qp_size_put_signal_warp():
    pass
    

def _lower__Z32nvshmemx_qp_size_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_size_put_signal_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_size_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_size_put_signal_warp_nbst = declare_device(
        '_Z32nvshmemx_qp_size_put_signal_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_size_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemx_qp_size_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_size_put_signal_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_size_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_size_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_size_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_size_put_signal_block():
    pass
    

def _lower__Z33nvshmemx_qp_size_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_size_put_signal_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_size_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_size_put_signal_block_nbst = declare_device(
        '_Z33nvshmemx_qp_size_put_signal_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_size_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_size_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_size_put_signal_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_size_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_size_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_size_put_signal_block_nbst(shim_stream, shim_obj)


def qp_ptrdiff_put_signal():
    pass
    

def _lower__Z30nvshmemx_qp_ptrdiff_put_signal_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_ptrdiff_put_signal_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ptrdiff_put_signal(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_ptrdiff_put_signal_nbst = declare_device(
        '_Z30nvshmemx_qp_ptrdiff_put_signal_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_ptrdiff_put_signal_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z30nvshmemx_qp_ptrdiff_put_signal_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ptrdiff_put_signal, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_ptrdiff_put_signal_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_ptrdiff_put_signal_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_ptrdiff_put_signal_nbst(shim_stream, shim_obj)


def qp_ptrdiff_put_signal_warp():
    pass
    

def _lower__Z35nvshmemx_qp_ptrdiff_put_signal_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_qp_ptrdiff_put_signal_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ptrdiff_put_signal_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z35nvshmemx_qp_ptrdiff_put_signal_warp_nbst = declare_device(
        '_Z35nvshmemx_qp_ptrdiff_put_signal_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_qp_ptrdiff_put_signal_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z35nvshmemx_qp_ptrdiff_put_signal_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ptrdiff_put_signal_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_qp_ptrdiff_put_signal_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_qp_ptrdiff_put_signal_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_qp_ptrdiff_put_signal_warp_nbst(shim_stream, shim_obj)


def qp_ptrdiff_put_signal_block():
    pass
    

def _lower__Z36nvshmemx_qp_ptrdiff_put_signal_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmemx_qp_ptrdiff_put_signal_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ptrdiff_put_signal_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z36nvshmemx_qp_ptrdiff_put_signal_block_nbst = declare_device(
        '_Z36nvshmemx_qp_ptrdiff_put_signal_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z36nvshmemx_qp_ptrdiff_put_signal_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z36nvshmemx_qp_ptrdiff_put_signal_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ptrdiff_put_signal_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z36nvshmemx_qp_ptrdiff_put_signal_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmemx_qp_ptrdiff_put_signal_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z36nvshmemx_qp_ptrdiff_put_signal_block_nbst(shim_stream, shim_obj)


def qp_bfloat16_put_signal_nbi():
    pass
    

def _lower__Z35nvshmemx_qp_bfloat16_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_qp_bfloat16_put_signal_nbi_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_bfloat16_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z35nvshmemx_qp_bfloat16_put_signal_nbi_nbst = declare_device(
        '_Z35nvshmemx_qp_bfloat16_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_qp_bfloat16_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z35nvshmemx_qp_bfloat16_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_bfloat16_put_signal_nbi, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_qp_bfloat16_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_qp_bfloat16_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_qp_bfloat16_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_bfloat16_put_signal_nbi_warp():
    pass
    

def _lower__Z40nvshmemx_qp_bfloat16_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z40nvshmemx_qp_bfloat16_put_signal_nbi_warp_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_bfloat16_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z40nvshmemx_qp_bfloat16_put_signal_nbi_warp_nbst = declare_device(
        '_Z40nvshmemx_qp_bfloat16_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z40nvshmemx_qp_bfloat16_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z40nvshmemx_qp_bfloat16_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_bfloat16_put_signal_nbi_warp, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z40nvshmemx_qp_bfloat16_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z40nvshmemx_qp_bfloat16_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z40nvshmemx_qp_bfloat16_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_bfloat16_put_signal_nbi_block():
    pass
    

def _lower__Z41nvshmemx_qp_bfloat16_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z41nvshmemx_qp_bfloat16_put_signal_nbi_block_nbst(int &retval , __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_bfloat16_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z41nvshmemx_qp_bfloat16_put_signal_nbi_block_nbst = declare_device(
        '_Z41nvshmemx_qp_bfloat16_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z41nvshmemx_qp_bfloat16_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z41nvshmemx_qp_bfloat16_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_bfloat16_put_signal_nbi_block, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z41nvshmemx_qp_bfloat16_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z41nvshmemx_qp_bfloat16_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z41nvshmemx_qp_bfloat16_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_half_put_signal_nbi():
    pass
    

def _lower__Z31nvshmemx_qp_half_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_half_put_signal_nbi_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_half_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_half_put_signal_nbi_nbst = declare_device(
        '_Z31nvshmemx_qp_half_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_half_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemx_qp_half_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_half_put_signal_nbi, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_half_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_half_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_half_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_half_put_signal_nbi_warp():
    pass
    

def _lower__Z36nvshmemx_qp_half_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmemx_qp_half_put_signal_nbi_warp_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_half_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z36nvshmemx_qp_half_put_signal_nbi_warp_nbst = declare_device(
        '_Z36nvshmemx_qp_half_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z36nvshmemx_qp_half_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z36nvshmemx_qp_half_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_half_put_signal_nbi_warp, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z36nvshmemx_qp_half_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmemx_qp_half_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z36nvshmemx_qp_half_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_half_put_signal_nbi_block():
    pass
    

def _lower__Z37nvshmemx_qp_half_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_qp_half_put_signal_nbi_block_nbst(int &retval , __half ** dest, __half ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_half_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z37nvshmemx_qp_half_put_signal_nbi_block_nbst = declare_device(
        '_Z37nvshmemx_qp_half_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_qp_half_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z37nvshmemx_qp_half_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_half_put_signal_nbi_block, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_qp_half_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_qp_half_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_qp_half_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_float_put_signal_nbi():
    pass
    

def _lower__Z32nvshmemx_qp_float_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_float_put_signal_nbi_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_float_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_float_put_signal_nbi_nbst = declare_device(
        '_Z32nvshmemx_qp_float_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_float_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemx_qp_float_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_float_put_signal_nbi, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_float_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_float_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_float_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_float_put_signal_nbi_warp():
    pass
    

def _lower__Z37nvshmemx_qp_float_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_qp_float_put_signal_nbi_warp_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_float_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z37nvshmemx_qp_float_put_signal_nbi_warp_nbst = declare_device(
        '_Z37nvshmemx_qp_float_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_qp_float_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z37nvshmemx_qp_float_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_float_put_signal_nbi_warp, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_qp_float_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_qp_float_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_qp_float_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_float_put_signal_nbi_block():
    pass
    

def _lower__Z38nvshmemx_qp_float_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmemx_qp_float_put_signal_nbi_block_nbst(int &retval , float ** dest, float ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_float_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z38nvshmemx_qp_float_put_signal_nbi_block_nbst = declare_device(
        '_Z38nvshmemx_qp_float_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z38nvshmemx_qp_float_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z38nvshmemx_qp_float_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_float_put_signal_nbi_block, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z38nvshmemx_qp_float_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmemx_qp_float_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z38nvshmemx_qp_float_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_double_put_signal_nbi():
    pass
    

def _lower__Z33nvshmemx_qp_double_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_double_put_signal_nbi_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_double_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_double_put_signal_nbi_nbst = declare_device(
        '_Z33nvshmemx_qp_double_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_double_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_double_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_double_put_signal_nbi, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_double_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_double_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_double_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_double_put_signal_nbi_warp():
    pass
    

def _lower__Z38nvshmemx_qp_double_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmemx_qp_double_put_signal_nbi_warp_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_double_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z38nvshmemx_qp_double_put_signal_nbi_warp_nbst = declare_device(
        '_Z38nvshmemx_qp_double_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z38nvshmemx_qp_double_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z38nvshmemx_qp_double_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_double_put_signal_nbi_warp, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z38nvshmemx_qp_double_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmemx_qp_double_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z38nvshmemx_qp_double_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_double_put_signal_nbi_block():
    pass
    

def _lower__Z39nvshmemx_qp_double_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z39nvshmemx_qp_double_put_signal_nbi_block_nbst(int &retval , double ** dest, double ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_double_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z39nvshmemx_qp_double_put_signal_nbi_block_nbst = declare_device(
        '_Z39nvshmemx_qp_double_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z39nvshmemx_qp_double_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z39nvshmemx_qp_double_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_double_put_signal_nbi_block, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z39nvshmemx_qp_double_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z39nvshmemx_qp_double_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z39nvshmemx_qp_double_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_char_put_signal_nbi():
    pass
    

def _lower__Z31nvshmemx_qp_char_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_char_put_signal_nbi_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_char_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_char_put_signal_nbi_nbst = declare_device(
        '_Z31nvshmemx_qp_char_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_char_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemx_qp_char_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_char_put_signal_nbi, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_char_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_char_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_char_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_char_put_signal_nbi_warp():
    pass
    

def _lower__Z36nvshmemx_qp_char_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmemx_qp_char_put_signal_nbi_warp_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_char_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z36nvshmemx_qp_char_put_signal_nbi_warp_nbst = declare_device(
        '_Z36nvshmemx_qp_char_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z36nvshmemx_qp_char_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z36nvshmemx_qp_char_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_char_put_signal_nbi_warp, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z36nvshmemx_qp_char_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmemx_qp_char_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z36nvshmemx_qp_char_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_char_put_signal_nbi_block():
    pass
    

def _lower__Z37nvshmemx_qp_char_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_qp_char_put_signal_nbi_block_nbst(int &retval , char ** dest, char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_char_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z37nvshmemx_qp_char_put_signal_nbi_block_nbst = declare_device(
        '_Z37nvshmemx_qp_char_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_qp_char_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z37nvshmemx_qp_char_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_char_put_signal_nbi_block, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_qp_char_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_qp_char_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_qp_char_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_short_put_signal_nbi():
    pass
    

def _lower__Z32nvshmemx_qp_short_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_short_put_signal_nbi_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_short_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_short_put_signal_nbi_nbst = declare_device(
        '_Z32nvshmemx_qp_short_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_short_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemx_qp_short_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_short_put_signal_nbi, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_short_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_short_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_short_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_short_put_signal_nbi_warp():
    pass
    

def _lower__Z37nvshmemx_qp_short_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_qp_short_put_signal_nbi_warp_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_short_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z37nvshmemx_qp_short_put_signal_nbi_warp_nbst = declare_device(
        '_Z37nvshmemx_qp_short_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_qp_short_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z37nvshmemx_qp_short_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_short_put_signal_nbi_warp, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_qp_short_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_qp_short_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_qp_short_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_short_put_signal_nbi_block():
    pass
    

def _lower__Z38nvshmemx_qp_short_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmemx_qp_short_put_signal_nbi_block_nbst(int &retval , short ** dest, short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_short_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z38nvshmemx_qp_short_put_signal_nbi_block_nbst = declare_device(
        '_Z38nvshmemx_qp_short_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z38nvshmemx_qp_short_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z38nvshmemx_qp_short_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_short_put_signal_nbi_block, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z38nvshmemx_qp_short_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmemx_qp_short_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z38nvshmemx_qp_short_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_schar_put_signal_nbi():
    pass
    

def _lower__Z32nvshmemx_qp_schar_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_schar_put_signal_nbi_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_schar_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_schar_put_signal_nbi_nbst = declare_device(
        '_Z32nvshmemx_qp_schar_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_schar_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemx_qp_schar_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_schar_put_signal_nbi, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_schar_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_schar_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_schar_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_schar_put_signal_nbi_warp():
    pass
    

def _lower__Z37nvshmemx_qp_schar_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_qp_schar_put_signal_nbi_warp_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_schar_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z37nvshmemx_qp_schar_put_signal_nbi_warp_nbst = declare_device(
        '_Z37nvshmemx_qp_schar_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_qp_schar_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z37nvshmemx_qp_schar_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_schar_put_signal_nbi_warp, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_qp_schar_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_qp_schar_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_qp_schar_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_schar_put_signal_nbi_block():
    pass
    

def _lower__Z38nvshmemx_qp_schar_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmemx_qp_schar_put_signal_nbi_block_nbst(int &retval , signed char ** dest, signed char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_schar_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z38nvshmemx_qp_schar_put_signal_nbi_block_nbst = declare_device(
        '_Z38nvshmemx_qp_schar_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z38nvshmemx_qp_schar_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z38nvshmemx_qp_schar_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_schar_put_signal_nbi_block, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z38nvshmemx_qp_schar_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmemx_qp_schar_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z38nvshmemx_qp_schar_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_int_put_signal_nbi():
    pass
    

def _lower__Z30nvshmemx_qp_int_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z30nvshmemx_qp_int_put_signal_nbi_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z30nvshmemx_qp_int_put_signal_nbi_nbst = declare_device(
        '_Z30nvshmemx_qp_int_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z30nvshmemx_qp_int_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z30nvshmemx_qp_int_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int_put_signal_nbi, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z30nvshmemx_qp_int_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z30nvshmemx_qp_int_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z30nvshmemx_qp_int_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_int_put_signal_nbi_warp():
    pass
    

def _lower__Z35nvshmemx_qp_int_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_qp_int_put_signal_nbi_warp_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z35nvshmemx_qp_int_put_signal_nbi_warp_nbst = declare_device(
        '_Z35nvshmemx_qp_int_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_qp_int_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z35nvshmemx_qp_int_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int_put_signal_nbi_warp, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_qp_int_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_qp_int_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_qp_int_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_int_put_signal_nbi_block():
    pass
    

def _lower__Z36nvshmemx_qp_int_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmemx_qp_int_put_signal_nbi_block_nbst(int &retval , int ** dest, int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z36nvshmemx_qp_int_put_signal_nbi_block_nbst = declare_device(
        '_Z36nvshmemx_qp_int_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z36nvshmemx_qp_int_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z36nvshmemx_qp_int_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int_put_signal_nbi_block, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z36nvshmemx_qp_int_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmemx_qp_int_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z36nvshmemx_qp_int_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_long_put_signal_nbi():
    pass
    

def _lower__Z31nvshmemx_qp_long_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_long_put_signal_nbi_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_long_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_long_put_signal_nbi_nbst = declare_device(
        '_Z31nvshmemx_qp_long_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_long_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemx_qp_long_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_long_put_signal_nbi, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_long_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_long_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_long_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_long_put_signal_nbi_warp():
    pass
    

def _lower__Z36nvshmemx_qp_long_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmemx_qp_long_put_signal_nbi_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_long_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z36nvshmemx_qp_long_put_signal_nbi_warp_nbst = declare_device(
        '_Z36nvshmemx_qp_long_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z36nvshmemx_qp_long_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z36nvshmemx_qp_long_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_long_put_signal_nbi_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z36nvshmemx_qp_long_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmemx_qp_long_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z36nvshmemx_qp_long_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_long_put_signal_nbi_block():
    pass
    

def _lower__Z37nvshmemx_qp_long_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_qp_long_put_signal_nbi_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_long_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z37nvshmemx_qp_long_put_signal_nbi_block_nbst = declare_device(
        '_Z37nvshmemx_qp_long_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_qp_long_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z37nvshmemx_qp_long_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_long_put_signal_nbi_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_qp_long_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_qp_long_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_qp_long_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_longlong_put_signal_nbi():
    pass
    

def _lower__Z35nvshmemx_qp_longlong_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z35nvshmemx_qp_longlong_put_signal_nbi_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_longlong_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z35nvshmemx_qp_longlong_put_signal_nbi_nbst = declare_device(
        '_Z35nvshmemx_qp_longlong_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z35nvshmemx_qp_longlong_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z35nvshmemx_qp_longlong_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_longlong_put_signal_nbi, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z35nvshmemx_qp_longlong_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z35nvshmemx_qp_longlong_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z35nvshmemx_qp_longlong_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_longlong_put_signal_nbi_warp():
    pass
    

def _lower__Z40nvshmemx_qp_longlong_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z40nvshmemx_qp_longlong_put_signal_nbi_warp_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_longlong_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z40nvshmemx_qp_longlong_put_signal_nbi_warp_nbst = declare_device(
        '_Z40nvshmemx_qp_longlong_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z40nvshmemx_qp_longlong_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z40nvshmemx_qp_longlong_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_longlong_put_signal_nbi_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z40nvshmemx_qp_longlong_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z40nvshmemx_qp_longlong_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z40nvshmemx_qp_longlong_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_longlong_put_signal_nbi_block():
    pass
    

def _lower__Z41nvshmemx_qp_longlong_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z41nvshmemx_qp_longlong_put_signal_nbi_block_nbst(int &retval , long long ** dest, long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_longlong_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z41nvshmemx_qp_longlong_put_signal_nbi_block_nbst = declare_device(
        '_Z41nvshmemx_qp_longlong_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z41nvshmemx_qp_longlong_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z41nvshmemx_qp_longlong_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_longlong_put_signal_nbi_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z41nvshmemx_qp_longlong_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z41nvshmemx_qp_longlong_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z41nvshmemx_qp_longlong_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_uchar_put_signal_nbi():
    pass
    

def _lower__Z32nvshmemx_qp_uchar_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_uchar_put_signal_nbi_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uchar_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_uchar_put_signal_nbi_nbst = declare_device(
        '_Z32nvshmemx_qp_uchar_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_uchar_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemx_qp_uchar_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uchar_put_signal_nbi, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_uchar_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_uchar_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_uchar_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_uchar_put_signal_nbi_warp():
    pass
    

def _lower__Z37nvshmemx_qp_uchar_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_qp_uchar_put_signal_nbi_warp_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uchar_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z37nvshmemx_qp_uchar_put_signal_nbi_warp_nbst = declare_device(
        '_Z37nvshmemx_qp_uchar_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_qp_uchar_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z37nvshmemx_qp_uchar_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uchar_put_signal_nbi_warp, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_qp_uchar_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_qp_uchar_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_qp_uchar_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_uchar_put_signal_nbi_block():
    pass
    

def _lower__Z38nvshmemx_qp_uchar_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmemx_qp_uchar_put_signal_nbi_block_nbst(int &retval , unsigned char ** dest, unsigned char ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uchar_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z38nvshmemx_qp_uchar_put_signal_nbi_block_nbst = declare_device(
        '_Z38nvshmemx_qp_uchar_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z38nvshmemx_qp_uchar_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z38nvshmemx_qp_uchar_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uchar_put_signal_nbi_block, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z38nvshmemx_qp_uchar_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmemx_qp_uchar_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z38nvshmemx_qp_uchar_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_ushort_put_signal_nbi():
    pass
    

def _lower__Z33nvshmemx_qp_ushort_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_ushort_put_signal_nbi_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ushort_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_ushort_put_signal_nbi_nbst = declare_device(
        '_Z33nvshmemx_qp_ushort_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_ushort_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_ushort_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ushort_put_signal_nbi, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_ushort_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_ushort_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_ushort_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_ushort_put_signal_nbi_warp():
    pass
    

def _lower__Z38nvshmemx_qp_ushort_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmemx_qp_ushort_put_signal_nbi_warp_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ushort_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z38nvshmemx_qp_ushort_put_signal_nbi_warp_nbst = declare_device(
        '_Z38nvshmemx_qp_ushort_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z38nvshmemx_qp_ushort_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z38nvshmemx_qp_ushort_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ushort_put_signal_nbi_warp, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z38nvshmemx_qp_ushort_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmemx_qp_ushort_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z38nvshmemx_qp_ushort_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_ushort_put_signal_nbi_block():
    pass
    

def _lower__Z39nvshmemx_qp_ushort_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z39nvshmemx_qp_ushort_put_signal_nbi_block_nbst(int &retval , unsigned short ** dest, unsigned short ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ushort_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z39nvshmemx_qp_ushort_put_signal_nbi_block_nbst = declare_device(
        '_Z39nvshmemx_qp_ushort_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z39nvshmemx_qp_ushort_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z39nvshmemx_qp_ushort_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ushort_put_signal_nbi_block, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z39nvshmemx_qp_ushort_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z39nvshmemx_qp_ushort_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z39nvshmemx_qp_ushort_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_uint_put_signal_nbi():
    pass
    

def _lower__Z31nvshmemx_qp_uint_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_uint_put_signal_nbi_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_uint_put_signal_nbi_nbst = declare_device(
        '_Z31nvshmemx_qp_uint_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_uint_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemx_qp_uint_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint_put_signal_nbi, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_uint_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_uint_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_uint_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_uint_put_signal_nbi_warp():
    pass
    

def _lower__Z36nvshmemx_qp_uint_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmemx_qp_uint_put_signal_nbi_warp_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z36nvshmemx_qp_uint_put_signal_nbi_warp_nbst = declare_device(
        '_Z36nvshmemx_qp_uint_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z36nvshmemx_qp_uint_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z36nvshmemx_qp_uint_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint_put_signal_nbi_warp, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z36nvshmemx_qp_uint_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmemx_qp_uint_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z36nvshmemx_qp_uint_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_uint_put_signal_nbi_block():
    pass
    

def _lower__Z37nvshmemx_qp_uint_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_qp_uint_put_signal_nbi_block_nbst(int &retval , unsigned int ** dest, unsigned int ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z37nvshmemx_qp_uint_put_signal_nbi_block_nbst = declare_device(
        '_Z37nvshmemx_qp_uint_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_qp_uint_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z37nvshmemx_qp_uint_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint_put_signal_nbi_block, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_qp_uint_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_qp_uint_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_qp_uint_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_ulong_put_signal_nbi():
    pass
    

def _lower__Z32nvshmemx_qp_ulong_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_ulong_put_signal_nbi_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ulong_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_ulong_put_signal_nbi_nbst = declare_device(
        '_Z32nvshmemx_qp_ulong_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_ulong_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemx_qp_ulong_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ulong_put_signal_nbi, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_ulong_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_ulong_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_ulong_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_ulong_put_signal_nbi_warp():
    pass
    

def _lower__Z37nvshmemx_qp_ulong_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_qp_ulong_put_signal_nbi_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ulong_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z37nvshmemx_qp_ulong_put_signal_nbi_warp_nbst = declare_device(
        '_Z37nvshmemx_qp_ulong_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_qp_ulong_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z37nvshmemx_qp_ulong_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ulong_put_signal_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_qp_ulong_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_qp_ulong_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_qp_ulong_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_ulong_put_signal_nbi_block():
    pass
    

def _lower__Z38nvshmemx_qp_ulong_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmemx_qp_ulong_put_signal_nbi_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ulong_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z38nvshmemx_qp_ulong_put_signal_nbi_block_nbst = declare_device(
        '_Z38nvshmemx_qp_ulong_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z38nvshmemx_qp_ulong_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z38nvshmemx_qp_ulong_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ulong_put_signal_nbi_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z38nvshmemx_qp_ulong_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmemx_qp_ulong_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z38nvshmemx_qp_ulong_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_ulonglong_put_signal_nbi():
    pass
    

def _lower__Z36nvshmemx_qp_ulonglong_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmemx_qp_ulonglong_put_signal_nbi_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ulonglong_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z36nvshmemx_qp_ulonglong_put_signal_nbi_nbst = declare_device(
        '_Z36nvshmemx_qp_ulonglong_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z36nvshmemx_qp_ulonglong_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z36nvshmemx_qp_ulonglong_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ulonglong_put_signal_nbi, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z36nvshmemx_qp_ulonglong_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmemx_qp_ulonglong_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z36nvshmemx_qp_ulonglong_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_ulonglong_put_signal_nbi_warp():
    pass
    

def _lower__Z41nvshmemx_qp_ulonglong_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z41nvshmemx_qp_ulonglong_put_signal_nbi_warp_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ulonglong_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z41nvshmemx_qp_ulonglong_put_signal_nbi_warp_nbst = declare_device(
        '_Z41nvshmemx_qp_ulonglong_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z41nvshmemx_qp_ulonglong_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z41nvshmemx_qp_ulonglong_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ulonglong_put_signal_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z41nvshmemx_qp_ulonglong_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z41nvshmemx_qp_ulonglong_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z41nvshmemx_qp_ulonglong_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_ulonglong_put_signal_nbi_block():
    pass
    

def _lower__Z42nvshmemx_qp_ulonglong_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z42nvshmemx_qp_ulonglong_put_signal_nbi_block_nbst(int &retval , unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ulonglong_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z42nvshmemx_qp_ulonglong_put_signal_nbi_block_nbst = declare_device(
        '_Z42nvshmemx_qp_ulonglong_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z42nvshmemx_qp_ulonglong_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z42nvshmemx_qp_ulonglong_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ulonglong_put_signal_nbi_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z42nvshmemx_qp_ulonglong_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z42nvshmemx_qp_ulonglong_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z42nvshmemx_qp_ulonglong_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_int8_put_signal_nbi():
    pass
    

def _lower__Z31nvshmemx_qp_int8_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_int8_put_signal_nbi_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int8_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_int8_put_signal_nbi_nbst = declare_device(
        '_Z31nvshmemx_qp_int8_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_int8_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemx_qp_int8_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int8_put_signal_nbi, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_int8_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_int8_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_int8_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_int8_put_signal_nbi_warp():
    pass
    

def _lower__Z36nvshmemx_qp_int8_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmemx_qp_int8_put_signal_nbi_warp_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int8_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z36nvshmemx_qp_int8_put_signal_nbi_warp_nbst = declare_device(
        '_Z36nvshmemx_qp_int8_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z36nvshmemx_qp_int8_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z36nvshmemx_qp_int8_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int8_put_signal_nbi_warp, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z36nvshmemx_qp_int8_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmemx_qp_int8_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z36nvshmemx_qp_int8_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_int8_put_signal_nbi_block():
    pass
    

def _lower__Z37nvshmemx_qp_int8_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_qp_int8_put_signal_nbi_block_nbst(int &retval , int8_t ** dest, int8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int8_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z37nvshmemx_qp_int8_put_signal_nbi_block_nbst = declare_device(
        '_Z37nvshmemx_qp_int8_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_qp_int8_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z37nvshmemx_qp_int8_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int8_put_signal_nbi_block, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_qp_int8_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_qp_int8_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_qp_int8_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_int16_put_signal_nbi():
    pass
    

def _lower__Z32nvshmemx_qp_int16_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_int16_put_signal_nbi_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int16_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_int16_put_signal_nbi_nbst = declare_device(
        '_Z32nvshmemx_qp_int16_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_int16_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemx_qp_int16_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int16_put_signal_nbi, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_int16_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_int16_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_int16_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_int16_put_signal_nbi_warp():
    pass
    

def _lower__Z37nvshmemx_qp_int16_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_qp_int16_put_signal_nbi_warp_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int16_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z37nvshmemx_qp_int16_put_signal_nbi_warp_nbst = declare_device(
        '_Z37nvshmemx_qp_int16_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_qp_int16_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z37nvshmemx_qp_int16_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int16_put_signal_nbi_warp, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_qp_int16_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_qp_int16_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_qp_int16_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_int16_put_signal_nbi_block():
    pass
    

def _lower__Z38nvshmemx_qp_int16_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmemx_qp_int16_put_signal_nbi_block_nbst(int &retval , int16_t ** dest, int16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int16_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z38nvshmemx_qp_int16_put_signal_nbi_block_nbst = declare_device(
        '_Z38nvshmemx_qp_int16_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z38nvshmemx_qp_int16_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z38nvshmemx_qp_int16_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int16_put_signal_nbi_block, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z38nvshmemx_qp_int16_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmemx_qp_int16_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z38nvshmemx_qp_int16_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_int32_put_signal_nbi():
    pass
    

def _lower__Z32nvshmemx_qp_int32_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_int32_put_signal_nbi_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int32_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_int32_put_signal_nbi_nbst = declare_device(
        '_Z32nvshmemx_qp_int32_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_int32_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemx_qp_int32_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int32_put_signal_nbi, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_int32_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_int32_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_int32_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_int32_put_signal_nbi_warp():
    pass
    

def _lower__Z37nvshmemx_qp_int32_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_qp_int32_put_signal_nbi_warp_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int32_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z37nvshmemx_qp_int32_put_signal_nbi_warp_nbst = declare_device(
        '_Z37nvshmemx_qp_int32_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_qp_int32_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z37nvshmemx_qp_int32_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int32_put_signal_nbi_warp, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_qp_int32_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_qp_int32_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_qp_int32_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_int32_put_signal_nbi_block():
    pass
    

def _lower__Z38nvshmemx_qp_int32_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmemx_qp_int32_put_signal_nbi_block_nbst(int &retval , int32_t ** dest, int32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int32_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z38nvshmemx_qp_int32_put_signal_nbi_block_nbst = declare_device(
        '_Z38nvshmemx_qp_int32_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z38nvshmemx_qp_int32_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z38nvshmemx_qp_int32_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int32_put_signal_nbi_block, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z38nvshmemx_qp_int32_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmemx_qp_int32_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z38nvshmemx_qp_int32_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_int64_put_signal_nbi():
    pass
    

def _lower__Z32nvshmemx_qp_int64_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_int64_put_signal_nbi_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int64_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_int64_put_signal_nbi_nbst = declare_device(
        '_Z32nvshmemx_qp_int64_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_int64_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemx_qp_int64_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int64_put_signal_nbi, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_int64_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_int64_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_int64_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_int64_put_signal_nbi_warp():
    pass
    

def _lower__Z37nvshmemx_qp_int64_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_qp_int64_put_signal_nbi_warp_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int64_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z37nvshmemx_qp_int64_put_signal_nbi_warp_nbst = declare_device(
        '_Z37nvshmemx_qp_int64_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_qp_int64_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z37nvshmemx_qp_int64_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int64_put_signal_nbi_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_qp_int64_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_qp_int64_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_qp_int64_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_int64_put_signal_nbi_block():
    pass
    

def _lower__Z38nvshmemx_qp_int64_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmemx_qp_int64_put_signal_nbi_block_nbst(int &retval , int64_t ** dest, int64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_int64_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z38nvshmemx_qp_int64_put_signal_nbi_block_nbst = declare_device(
        '_Z38nvshmemx_qp_int64_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z38nvshmemx_qp_int64_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z38nvshmemx_qp_int64_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_int64_put_signal_nbi_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z38nvshmemx_qp_int64_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmemx_qp_int64_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z38nvshmemx_qp_int64_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_uint8_put_signal_nbi():
    pass
    

def _lower__Z32nvshmemx_qp_uint8_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z32nvshmemx_qp_uint8_put_signal_nbi_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint8_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z32nvshmemx_qp_uint8_put_signal_nbi_nbst = declare_device(
        '_Z32nvshmemx_qp_uint8_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z32nvshmemx_qp_uint8_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z32nvshmemx_qp_uint8_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint8_put_signal_nbi, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z32nvshmemx_qp_uint8_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z32nvshmemx_qp_uint8_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z32nvshmemx_qp_uint8_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_uint8_put_signal_nbi_warp():
    pass
    

def _lower__Z37nvshmemx_qp_uint8_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_qp_uint8_put_signal_nbi_warp_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint8_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z37nvshmemx_qp_uint8_put_signal_nbi_warp_nbst = declare_device(
        '_Z37nvshmemx_qp_uint8_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_qp_uint8_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z37nvshmemx_qp_uint8_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint8_put_signal_nbi_warp, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_qp_uint8_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_qp_uint8_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_qp_uint8_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_uint8_put_signal_nbi_block():
    pass
    

def _lower__Z38nvshmemx_qp_uint8_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmemx_qp_uint8_put_signal_nbi_block_nbst(int &retval , uint8_t ** dest, uint8_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint8_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z38nvshmemx_qp_uint8_put_signal_nbi_block_nbst = declare_device(
        '_Z38nvshmemx_qp_uint8_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z38nvshmemx_qp_uint8_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z38nvshmemx_qp_uint8_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint8_put_signal_nbi_block, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z38nvshmemx_qp_uint8_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmemx_qp_uint8_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z38nvshmemx_qp_uint8_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_uint16_put_signal_nbi():
    pass
    

def _lower__Z33nvshmemx_qp_uint16_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_uint16_put_signal_nbi_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint16_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_uint16_put_signal_nbi_nbst = declare_device(
        '_Z33nvshmemx_qp_uint16_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_uint16_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_uint16_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint16_put_signal_nbi, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_uint16_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_uint16_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_uint16_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_uint16_put_signal_nbi_warp():
    pass
    

def _lower__Z38nvshmemx_qp_uint16_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmemx_qp_uint16_put_signal_nbi_warp_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint16_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z38nvshmemx_qp_uint16_put_signal_nbi_warp_nbst = declare_device(
        '_Z38nvshmemx_qp_uint16_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z38nvshmemx_qp_uint16_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z38nvshmemx_qp_uint16_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint16_put_signal_nbi_warp, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z38nvshmemx_qp_uint16_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmemx_qp_uint16_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z38nvshmemx_qp_uint16_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_uint16_put_signal_nbi_block():
    pass
    

def _lower__Z39nvshmemx_qp_uint16_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z39nvshmemx_qp_uint16_put_signal_nbi_block_nbst(int &retval , uint16_t ** dest, uint16_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint16_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z39nvshmemx_qp_uint16_put_signal_nbi_block_nbst = declare_device(
        '_Z39nvshmemx_qp_uint16_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z39nvshmemx_qp_uint16_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z39nvshmemx_qp_uint16_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint16_put_signal_nbi_block, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z39nvshmemx_qp_uint16_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z39nvshmemx_qp_uint16_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z39nvshmemx_qp_uint16_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_uint32_put_signal_nbi():
    pass
    

def _lower__Z33nvshmemx_qp_uint32_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_uint32_put_signal_nbi_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint32_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_uint32_put_signal_nbi_nbst = declare_device(
        '_Z33nvshmemx_qp_uint32_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_uint32_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_uint32_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint32_put_signal_nbi, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_uint32_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_uint32_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_uint32_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_uint32_put_signal_nbi_warp():
    pass
    

def _lower__Z38nvshmemx_qp_uint32_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmemx_qp_uint32_put_signal_nbi_warp_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint32_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z38nvshmemx_qp_uint32_put_signal_nbi_warp_nbst = declare_device(
        '_Z38nvshmemx_qp_uint32_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z38nvshmemx_qp_uint32_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z38nvshmemx_qp_uint32_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint32_put_signal_nbi_warp, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z38nvshmemx_qp_uint32_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmemx_qp_uint32_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z38nvshmemx_qp_uint32_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_uint32_put_signal_nbi_block():
    pass
    

def _lower__Z39nvshmemx_qp_uint32_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z39nvshmemx_qp_uint32_put_signal_nbi_block_nbst(int &retval , uint32_t ** dest, uint32_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint32_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z39nvshmemx_qp_uint32_put_signal_nbi_block_nbst = declare_device(
        '_Z39nvshmemx_qp_uint32_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z39nvshmemx_qp_uint32_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z39nvshmemx_qp_uint32_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint32_put_signal_nbi_block, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z39nvshmemx_qp_uint32_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z39nvshmemx_qp_uint32_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z39nvshmemx_qp_uint32_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_uint64_put_signal_nbi():
    pass
    

def _lower__Z33nvshmemx_qp_uint64_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z33nvshmemx_qp_uint64_put_signal_nbi_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint64_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z33nvshmemx_qp_uint64_put_signal_nbi_nbst = declare_device(
        '_Z33nvshmemx_qp_uint64_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z33nvshmemx_qp_uint64_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z33nvshmemx_qp_uint64_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint64_put_signal_nbi, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z33nvshmemx_qp_uint64_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z33nvshmemx_qp_uint64_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z33nvshmemx_qp_uint64_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_uint64_put_signal_nbi_warp():
    pass
    

def _lower__Z38nvshmemx_qp_uint64_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z38nvshmemx_qp_uint64_put_signal_nbi_warp_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint64_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z38nvshmemx_qp_uint64_put_signal_nbi_warp_nbst = declare_device(
        '_Z38nvshmemx_qp_uint64_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z38nvshmemx_qp_uint64_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z38nvshmemx_qp_uint64_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint64_put_signal_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z38nvshmemx_qp_uint64_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z38nvshmemx_qp_uint64_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z38nvshmemx_qp_uint64_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_uint64_put_signal_nbi_block():
    pass
    

def _lower__Z39nvshmemx_qp_uint64_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z39nvshmemx_qp_uint64_put_signal_nbi_block_nbst(int &retval , uint64_t ** dest, uint64_t ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_uint64_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z39nvshmemx_qp_uint64_put_signal_nbi_block_nbst = declare_device(
        '_Z39nvshmemx_qp_uint64_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z39nvshmemx_qp_uint64_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z39nvshmemx_qp_uint64_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_uint64_put_signal_nbi_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z39nvshmemx_qp_uint64_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z39nvshmemx_qp_uint64_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z39nvshmemx_qp_uint64_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_size_put_signal_nbi():
    pass
    

def _lower__Z31nvshmemx_qp_size_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z31nvshmemx_qp_size_put_signal_nbi_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_size_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z31nvshmemx_qp_size_put_signal_nbi_nbst = declare_device(
        '_Z31nvshmemx_qp_size_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z31nvshmemx_qp_size_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z31nvshmemx_qp_size_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_size_put_signal_nbi, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z31nvshmemx_qp_size_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z31nvshmemx_qp_size_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z31nvshmemx_qp_size_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_size_put_signal_nbi_warp():
    pass
    

def _lower__Z36nvshmemx_qp_size_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z36nvshmemx_qp_size_put_signal_nbi_warp_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_size_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z36nvshmemx_qp_size_put_signal_nbi_warp_nbst = declare_device(
        '_Z36nvshmemx_qp_size_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z36nvshmemx_qp_size_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z36nvshmemx_qp_size_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_size_put_signal_nbi_warp, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z36nvshmemx_qp_size_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z36nvshmemx_qp_size_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z36nvshmemx_qp_size_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_size_put_signal_nbi_block():
    pass
    

def _lower__Z37nvshmemx_qp_size_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z37nvshmemx_qp_size_put_signal_nbi_block_nbst(int &retval , unsigned long ** dest, unsigned long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_size_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z37nvshmemx_qp_size_put_signal_nbi_block_nbst = declare_device(
        '_Z37nvshmemx_qp_size_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z37nvshmemx_qp_size_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z37nvshmemx_qp_size_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_size_put_signal_nbi_block, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z37nvshmemx_qp_size_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z37nvshmemx_qp_size_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z37nvshmemx_qp_size_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_ptrdiff_put_signal_nbi():
    pass
    

def _lower__Z34nvshmemx_qp_ptrdiff_put_signal_nbi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z34nvshmemx_qp_ptrdiff_put_signal_nbi_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ptrdiff_put_signal_nbi(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z34nvshmemx_qp_ptrdiff_put_signal_nbi_nbst = declare_device(
        '_Z34nvshmemx_qp_ptrdiff_put_signal_nbi_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z34nvshmemx_qp_ptrdiff_put_signal_nbi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z34nvshmemx_qp_ptrdiff_put_signal_nbi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ptrdiff_put_signal_nbi, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z34nvshmemx_qp_ptrdiff_put_signal_nbi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z34nvshmemx_qp_ptrdiff_put_signal_nbi_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z34nvshmemx_qp_ptrdiff_put_signal_nbi_nbst(shim_stream, shim_obj)


def qp_ptrdiff_put_signal_nbi_warp():
    pass
    

def _lower__Z39nvshmemx_qp_ptrdiff_put_signal_nbi_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z39nvshmemx_qp_ptrdiff_put_signal_nbi_warp_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ptrdiff_put_signal_nbi_warp(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z39nvshmemx_qp_ptrdiff_put_signal_nbi_warp_nbst = declare_device(
        '_Z39nvshmemx_qp_ptrdiff_put_signal_nbi_warp_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z39nvshmemx_qp_ptrdiff_put_signal_nbi_warp_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z39nvshmemx_qp_ptrdiff_put_signal_nbi_warp_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ptrdiff_put_signal_nbi_warp, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z39nvshmemx_qp_ptrdiff_put_signal_nbi_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z39nvshmemx_qp_ptrdiff_put_signal_nbi_warp_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z39nvshmemx_qp_ptrdiff_put_signal_nbi_warp_nbst(shim_stream, shim_obj)


def qp_ptrdiff_put_signal_nbi_block():
    pass
    

def _lower__Z40nvshmemx_qp_ptrdiff_put_signal_nbi_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z40nvshmemx_qp_ptrdiff_put_signal_nbi_block_nbst(int &retval , long ** dest, long ** source, unsigned long* nelems, uint64_t ** sig_addr, uint64_t* signal, int* sig_op, int* pe, int* qp_index) {
        nvshmemx_qp_ptrdiff_put_signal_nbi_block(*dest, *source, *nelems, *sig_addr, *signal, *sig_op, *pe, *qp_index);
        return 0;
    }
        """


    _Z40nvshmemx_qp_ptrdiff_put_signal_nbi_block_nbst = declare_device(
        '_Z40nvshmemx_qp_ptrdiff_put_signal_nbi_block_nbst',
        void(
            CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)
        )
    )
    

    def _Z40nvshmemx_qp_ptrdiff_put_signal_nbi_block_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7):
        return _Z40nvshmemx_qp_ptrdiff_put_signal_nbi_block_nbst(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7)
    

    @lower(qp_ptrdiff_put_signal_nbi_block, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z40nvshmemx_qp_ptrdiff_put_signal_nbi_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z40nvshmemx_qp_ptrdiff_put_signal_nbi_block_nbst_caller,
            signature(void, CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32), CPointer(int32), CPointer(int32)),
            ptrs,
        )



_lower__Z40nvshmemx_qp_ptrdiff_put_signal_nbi_block_nbst(shim_stream, shim_obj)


def qp_quiet():
    pass
    

def _lower__Z17nvshmemx_qp_quiet_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmemx_qp_quiet_nbst(int &retval , int* pe, int ** qp_handle, int* num_qps) {
        nvshmemx_qp_quiet(*pe, *qp_handle, *num_qps);
        return 0;
    }
        """


    _Z17nvshmemx_qp_quiet_nbst = declare_device(
        '_Z17nvshmemx_qp_quiet_nbst',
        void(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(int32)
        )
    )
    

    def _Z17nvshmemx_qp_quiet_nbst_caller(arg_0, arg_1, arg_2):
        return _Z17nvshmemx_qp_quiet_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_quiet, int32, CPointer(int32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmemx_qp_quiet_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmemx_qp_quiet_nbst_caller,
            signature(void, CPointer(int32), CPointer(CPointer(int32)), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmemx_qp_quiet_nbst(shim_stream, shim_obj)


def qp_quiet_warp():
    pass
    

def _lower__Z22nvshmemx_qp_quiet_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_qp_quiet_warp_nbst(int &retval , int* pe, int ** qp_handle, int* num_qps) {
        nvshmemx_qp_quiet_warp(*pe, *qp_handle, *num_qps);
        return 0;
    }
        """


    _Z22nvshmemx_qp_quiet_warp_nbst = declare_device(
        '_Z22nvshmemx_qp_quiet_warp_nbst',
        void(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_qp_quiet_warp_nbst_caller(arg_0, arg_1, arg_2):
        return _Z22nvshmemx_qp_quiet_warp_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_quiet_warp, int32, CPointer(int32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_qp_quiet_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_qp_quiet_warp_nbst_caller,
            signature(void, CPointer(int32), CPointer(CPointer(int32)), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_qp_quiet_warp_nbst(shim_stream, shim_obj)


def qp_quiet_block():
    pass
    

def _lower__Z23nvshmemx_qp_quiet_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_qp_quiet_block_nbst(int &retval , int* pe, int ** qp_handle, int* num_qps) {
        nvshmemx_qp_quiet_block(*pe, *qp_handle, *num_qps);
        return 0;
    }
        """


    _Z23nvshmemx_qp_quiet_block_nbst = declare_device(
        '_Z23nvshmemx_qp_quiet_block_nbst',
        void(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_qp_quiet_block_nbst_caller(arg_0, arg_1, arg_2):
        return _Z23nvshmemx_qp_quiet_block_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_quiet_block, int32, CPointer(int32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_qp_quiet_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_qp_quiet_block_nbst_caller,
            signature(void, CPointer(int32), CPointer(CPointer(int32)), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_qp_quiet_block_nbst(shim_stream, shim_obj)


def qp_fence():
    pass
    

def _lower__Z17nvshmemx_qp_fence_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z17nvshmemx_qp_fence_nbst(int &retval , int* pe, int ** qp_handle, int* num_qps) {
        nvshmemx_qp_fence(*pe, *qp_handle, *num_qps);
        return 0;
    }
        """


    _Z17nvshmemx_qp_fence_nbst = declare_device(
        '_Z17nvshmemx_qp_fence_nbst',
        void(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(int32)
        )
    )
    

    def _Z17nvshmemx_qp_fence_nbst_caller(arg_0, arg_1, arg_2):
        return _Z17nvshmemx_qp_fence_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_fence, int32, CPointer(int32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z17nvshmemx_qp_fence_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z17nvshmemx_qp_fence_nbst_caller,
            signature(void, CPointer(int32), CPointer(CPointer(int32)), CPointer(int32)),
            ptrs,
        )



_lower__Z17nvshmemx_qp_fence_nbst(shim_stream, shim_obj)


def qp_fence_warp():
    pass
    

def _lower__Z22nvshmemx_qp_fence_warp_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z22nvshmemx_qp_fence_warp_nbst(int &retval , int* pe, int ** qp_handle, int* num_qps) {
        nvshmemx_qp_fence_warp(*pe, *qp_handle, *num_qps);
        return 0;
    }
        """


    _Z22nvshmemx_qp_fence_warp_nbst = declare_device(
        '_Z22nvshmemx_qp_fence_warp_nbst',
        void(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(int32)
        )
    )
    

    def _Z22nvshmemx_qp_fence_warp_nbst_caller(arg_0, arg_1, arg_2):
        return _Z22nvshmemx_qp_fence_warp_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_fence_warp, int32, CPointer(int32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z22nvshmemx_qp_fence_warp_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z22nvshmemx_qp_fence_warp_nbst_caller,
            signature(void, CPointer(int32), CPointer(CPointer(int32)), CPointer(int32)),
            ptrs,
        )



_lower__Z22nvshmemx_qp_fence_warp_nbst(shim_stream, shim_obj)


def qp_fence_block():
    pass
    

def _lower__Z23nvshmemx_qp_fence_block_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _Z23nvshmemx_qp_fence_block_nbst(int &retval , int* pe, int ** qp_handle, int* num_qps) {
        nvshmemx_qp_fence_block(*pe, *qp_handle, *num_qps);
        return 0;
    }
        """


    _Z23nvshmemx_qp_fence_block_nbst = declare_device(
        '_Z23nvshmemx_qp_fence_block_nbst',
        void(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(int32)
        )
    )
    

    def _Z23nvshmemx_qp_fence_block_nbst_caller(arg_0, arg_1, arg_2):
        return _Z23nvshmemx_qp_fence_block_nbst(arg_0, arg_1, arg_2)
    

    @lower(qp_fence_block, int32, CPointer(int32), int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_Z23nvshmemx_qp_fence_block_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _Z23nvshmemx_qp_fence_block_nbst_caller,
            signature(void, CPointer(int32), CPointer(CPointer(int32)), CPointer(int32)),
            ptrs,
        )



_lower__Z23nvshmemx_qp_fence_block_nbst(shim_stream, shim_obj)


def alltoallmem_warp():
    pass
    

def _lower__ZL25nvshmemx_alltoallmem_warpiPvPKvm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmemx_alltoallmem_warpiPvPKvm_nbst(int &retval , int* team, void ** dest, void ** source, unsigned long* nelems) {
        retval = nvshmemx_alltoallmem_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL25nvshmemx_alltoallmem_warpiPvPKvm_nbst = declare_device(
        '_ZL25nvshmemx_alltoallmem_warpiPvPKvm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmemx_alltoallmem_warpiPvPKvm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmemx_alltoallmem_warpiPvPKvm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(alltoallmem_warp, int32, CPointer(void), CPointer(void), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmemx_alltoallmem_warpiPvPKvm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmemx_alltoallmem_warpiPvPKvm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmemx_alltoallmem_warpiPvPKvm_nbst(shim_stream, shim_obj)


def alltoallmem_block():
    pass
    

def _lower__ZL26nvshmemx_alltoallmem_blockiPvPKvm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL26nvshmemx_alltoallmem_blockiPvPKvm_nbst(int &retval , int* team, void ** dest, void ** source, unsigned long* nelems) {
        retval = nvshmemx_alltoallmem_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL26nvshmemx_alltoallmem_blockiPvPKvm_nbst = declare_device(
        '_ZL26nvshmemx_alltoallmem_blockiPvPKvm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64)
        )
    )
    

    def _ZL26nvshmemx_alltoallmem_blockiPvPKvm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL26nvshmemx_alltoallmem_blockiPvPKvm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(alltoallmem_block, int32, CPointer(void), CPointer(void), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL26nvshmemx_alltoallmem_blockiPvPKvm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL26nvshmemx_alltoallmem_blockiPvPKvm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL26nvshmemx_alltoallmem_blockiPvPKvm_nbst(shim_stream, shim_obj)


def bfloat16_alltoall_warp():
    pass
    

def _lower__ZL31nvshmemx_bfloat16_alltoall_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_bfloat16_alltoall_warpiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems) {
        retval = nvshmemx_bfloat16_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL31nvshmemx_bfloat16_alltoall_warpiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL31nvshmemx_bfloat16_alltoall_warpiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_bfloat16_alltoall_warpiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_bfloat16_alltoall_warpiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_alltoall_warp, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_bfloat16_alltoall_warpiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_bfloat16_alltoall_warpiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_bfloat16_alltoall_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_alltoall_warp():
    pass
    

def _lower__ZL27nvshmemx_half_alltoall_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmemx_half_alltoall_warpiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nelems) {
        retval = nvshmemx_half_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL27nvshmemx_half_alltoall_warpiP6__halfPKS_m_nbst = declare_device(
        '_ZL27nvshmemx_half_alltoall_warpiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmemx_half_alltoall_warpiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmemx_half_alltoall_warpiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_alltoall_warp, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmemx_half_alltoall_warpiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmemx_half_alltoall_warpiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmemx_half_alltoall_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_alltoall_warp():
    pass
    

def _lower__ZL28nvshmemx_float_alltoall_warpiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_float_alltoall_warpiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nelems) {
        retval = nvshmemx_float_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_float_alltoall_warpiPfPKfm_nbst = declare_device(
        '_ZL28nvshmemx_float_alltoall_warpiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_float_alltoall_warpiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_float_alltoall_warpiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_alltoall_warp, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_float_alltoall_warpiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_float_alltoall_warpiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_float_alltoall_warpiPfPKfm_nbst(shim_stream, shim_obj)


def double_alltoall_warp():
    pass
    

def _lower__ZL29nvshmemx_double_alltoall_warpiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_double_alltoall_warpiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nelems) {
        retval = nvshmemx_double_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_double_alltoall_warpiPdPKdm_nbst = declare_device(
        '_ZL29nvshmemx_double_alltoall_warpiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_double_alltoall_warpiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_double_alltoall_warpiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_alltoall_warp, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_double_alltoall_warpiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_double_alltoall_warpiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_double_alltoall_warpiPdPKdm_nbst(shim_stream, shim_obj)


def char_alltoall_warp():
    pass
    

def _lower__ZL27nvshmemx_char_alltoall_warpiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmemx_char_alltoall_warpiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nelems) {
        retval = nvshmemx_char_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL27nvshmemx_char_alltoall_warpiPcPKcm_nbst = declare_device(
        '_ZL27nvshmemx_char_alltoall_warpiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmemx_char_alltoall_warpiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmemx_char_alltoall_warpiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_alltoall_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmemx_char_alltoall_warpiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmemx_char_alltoall_warpiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmemx_char_alltoall_warpiPcPKcm_nbst(shim_stream, shim_obj)


def short_alltoall_warp():
    pass
    

def _lower__ZL28nvshmemx_short_alltoall_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_short_alltoall_warpiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nelems) {
        retval = nvshmemx_short_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_short_alltoall_warpiPsPKsm_nbst = declare_device(
        '_ZL28nvshmemx_short_alltoall_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_short_alltoall_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_short_alltoall_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_alltoall_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_short_alltoall_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_short_alltoall_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_short_alltoall_warpiPsPKsm_nbst(shim_stream, shim_obj)


def schar_alltoall_warp():
    pass
    

def _lower__ZL28nvshmemx_schar_alltoall_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_schar_alltoall_warpiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nelems) {
        retval = nvshmemx_schar_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_schar_alltoall_warpiPaPKam_nbst = declare_device(
        '_ZL28nvshmemx_schar_alltoall_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_schar_alltoall_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_schar_alltoall_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_alltoall_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_schar_alltoall_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_schar_alltoall_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_schar_alltoall_warpiPaPKam_nbst(shim_stream, shim_obj)


def int_alltoall_warp():
    pass
    

def _lower__ZL26nvshmemx_int_alltoall_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL26nvshmemx_int_alltoall_warpiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nelems) {
        retval = nvshmemx_int_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL26nvshmemx_int_alltoall_warpiPiPKim_nbst = declare_device(
        '_ZL26nvshmemx_int_alltoall_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL26nvshmemx_int_alltoall_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL26nvshmemx_int_alltoall_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_alltoall_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL26nvshmemx_int_alltoall_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL26nvshmemx_int_alltoall_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL26nvshmemx_int_alltoall_warpiPiPKim_nbst(shim_stream, shim_obj)


def long_alltoall_warp():
    pass
    

def _lower__ZL27nvshmemx_long_alltoall_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmemx_long_alltoall_warpiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nelems) {
        retval = nvshmemx_long_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL27nvshmemx_long_alltoall_warpiPlPKlm_nbst = declare_device(
        '_ZL27nvshmemx_long_alltoall_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmemx_long_alltoall_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmemx_long_alltoall_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_alltoall_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmemx_long_alltoall_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmemx_long_alltoall_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmemx_long_alltoall_warpiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_alltoall_warp():
    pass
    

def _lower__ZL31nvshmemx_longlong_alltoall_warpiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_longlong_alltoall_warpiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nelems) {
        retval = nvshmemx_longlong_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL31nvshmemx_longlong_alltoall_warpiPxPKxm_nbst = declare_device(
        '_ZL31nvshmemx_longlong_alltoall_warpiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_longlong_alltoall_warpiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_longlong_alltoall_warpiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_alltoall_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_longlong_alltoall_warpiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_longlong_alltoall_warpiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_longlong_alltoall_warpiPxPKxm_nbst(shim_stream, shim_obj)


def uchar_alltoall_warp():
    pass
    

def _lower__ZL28nvshmemx_uchar_alltoall_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_uchar_alltoall_warpiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nelems) {
        retval = nvshmemx_uchar_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_uchar_alltoall_warpiPhPKhm_nbst = declare_device(
        '_ZL28nvshmemx_uchar_alltoall_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_uchar_alltoall_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_uchar_alltoall_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_alltoall_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_uchar_alltoall_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_uchar_alltoall_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_uchar_alltoall_warpiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_alltoall_warp():
    pass
    

def _lower__ZL29nvshmemx_ushort_alltoall_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_ushort_alltoall_warpiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nelems) {
        retval = nvshmemx_ushort_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_ushort_alltoall_warpiPtPKtm_nbst = declare_device(
        '_ZL29nvshmemx_ushort_alltoall_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_ushort_alltoall_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_ushort_alltoall_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_alltoall_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_ushort_alltoall_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_ushort_alltoall_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_ushort_alltoall_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint_alltoall_warp():
    pass
    

def _lower__ZL27nvshmemx_uint_alltoall_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmemx_uint_alltoall_warpiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nelems) {
        retval = nvshmemx_uint_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL27nvshmemx_uint_alltoall_warpiPjPKjm_nbst = declare_device(
        '_ZL27nvshmemx_uint_alltoall_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmemx_uint_alltoall_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmemx_uint_alltoall_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_alltoall_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmemx_uint_alltoall_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmemx_uint_alltoall_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmemx_uint_alltoall_warpiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_alltoall_warp():
    pass
    

def _lower__ZL28nvshmemx_ulong_alltoall_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_ulong_alltoall_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nelems) {
        retval = nvshmemx_ulong_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_ulong_alltoall_warpiPmPKmm_nbst = declare_device(
        '_ZL28nvshmemx_ulong_alltoall_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_ulong_alltoall_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_ulong_alltoall_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_alltoall_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_ulong_alltoall_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_ulong_alltoall_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_ulong_alltoall_warpiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_alltoall_warp():
    pass
    

def _lower__ZL32nvshmemx_ulonglong_alltoall_warpiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_ulonglong_alltoall_warpiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems) {
        retval = nvshmemx_ulonglong_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL32nvshmemx_ulonglong_alltoall_warpiPyPKym_nbst = declare_device(
        '_ZL32nvshmemx_ulonglong_alltoall_warpiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_ulonglong_alltoall_warpiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_ulonglong_alltoall_warpiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_alltoall_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_ulonglong_alltoall_warpiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_ulonglong_alltoall_warpiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_ulonglong_alltoall_warpiPyPKym_nbst(shim_stream, shim_obj)


def int8_alltoall_warp():
    pass
    

def _lower__ZL27nvshmemx_int8_alltoall_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmemx_int8_alltoall_warpiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nelems) {
        retval = nvshmemx_int8_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL27nvshmemx_int8_alltoall_warpiPaPKam_nbst = declare_device(
        '_ZL27nvshmemx_int8_alltoall_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmemx_int8_alltoall_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmemx_int8_alltoall_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_alltoall_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmemx_int8_alltoall_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmemx_int8_alltoall_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmemx_int8_alltoall_warpiPaPKam_nbst(shim_stream, shim_obj)


def int16_alltoall_warp():
    pass
    

def _lower__ZL28nvshmemx_int16_alltoall_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_int16_alltoall_warpiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nelems) {
        retval = nvshmemx_int16_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_int16_alltoall_warpiPsPKsm_nbst = declare_device(
        '_ZL28nvshmemx_int16_alltoall_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_int16_alltoall_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_int16_alltoall_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_alltoall_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_int16_alltoall_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_int16_alltoall_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_int16_alltoall_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int32_alltoall_warp():
    pass
    

def _lower__ZL28nvshmemx_int32_alltoall_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_int32_alltoall_warpiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nelems) {
        retval = nvshmemx_int32_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_int32_alltoall_warpiPiPKim_nbst = declare_device(
        '_ZL28nvshmemx_int32_alltoall_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_int32_alltoall_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_int32_alltoall_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_alltoall_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_int32_alltoall_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_int32_alltoall_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_int32_alltoall_warpiPiPKim_nbst(shim_stream, shim_obj)


def int64_alltoall_warp():
    pass
    

def _lower__ZL28nvshmemx_int64_alltoall_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_int64_alltoall_warpiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nelems) {
        retval = nvshmemx_int64_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_int64_alltoall_warpiPlPKlm_nbst = declare_device(
        '_ZL28nvshmemx_int64_alltoall_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_int64_alltoall_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_int64_alltoall_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_alltoall_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_int64_alltoall_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_int64_alltoall_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_int64_alltoall_warpiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_alltoall_warp():
    pass
    

def _lower__ZL28nvshmemx_uint8_alltoall_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_uint8_alltoall_warpiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nelems) {
        retval = nvshmemx_uint8_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_uint8_alltoall_warpiPhPKhm_nbst = declare_device(
        '_ZL28nvshmemx_uint8_alltoall_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_uint8_alltoall_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_uint8_alltoall_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_alltoall_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_uint8_alltoall_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_uint8_alltoall_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_uint8_alltoall_warpiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_alltoall_warp():
    pass
    

def _lower__ZL29nvshmemx_uint16_alltoall_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uint16_alltoall_warpiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nelems) {
        retval = nvshmemx_uint16_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_uint16_alltoall_warpiPtPKtm_nbst = declare_device(
        '_ZL29nvshmemx_uint16_alltoall_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_uint16_alltoall_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_uint16_alltoall_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_alltoall_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uint16_alltoall_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uint16_alltoall_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_uint16_alltoall_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_alltoall_warp():
    pass
    

def _lower__ZL29nvshmemx_uint32_alltoall_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uint32_alltoall_warpiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nelems) {
        retval = nvshmemx_uint32_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_uint32_alltoall_warpiPjPKjm_nbst = declare_device(
        '_ZL29nvshmemx_uint32_alltoall_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_uint32_alltoall_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_uint32_alltoall_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_alltoall_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uint32_alltoall_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uint32_alltoall_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_uint32_alltoall_warpiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_alltoall_warp():
    pass
    

def _lower__ZL29nvshmemx_uint64_alltoall_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uint64_alltoall_warpiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nelems) {
        retval = nvshmemx_uint64_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_uint64_alltoall_warpiPmPKmm_nbst = declare_device(
        '_ZL29nvshmemx_uint64_alltoall_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_uint64_alltoall_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_uint64_alltoall_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_alltoall_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uint64_alltoall_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uint64_alltoall_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_uint64_alltoall_warpiPmPKmm_nbst(shim_stream, shim_obj)


def size_alltoall_warp():
    pass
    

def _lower__ZL27nvshmemx_size_alltoall_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmemx_size_alltoall_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nelems) {
        retval = nvshmemx_size_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL27nvshmemx_size_alltoall_warpiPmPKmm_nbst = declare_device(
        '_ZL27nvshmemx_size_alltoall_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmemx_size_alltoall_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmemx_size_alltoall_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_alltoall_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmemx_size_alltoall_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmemx_size_alltoall_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmemx_size_alltoall_warpiPmPKmm_nbst(shim_stream, shim_obj)


def ptrdiff_alltoall_warp():
    pass
    

def _lower__ZL30nvshmemx_ptrdiff_alltoall_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_ptrdiff_alltoall_warpiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nelems) {
        retval = nvshmemx_ptrdiff_alltoall_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL30nvshmemx_ptrdiff_alltoall_warpiPlPKlm_nbst = declare_device(
        '_ZL30nvshmemx_ptrdiff_alltoall_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_ptrdiff_alltoall_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_ptrdiff_alltoall_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ptrdiff_alltoall_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_ptrdiff_alltoall_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_ptrdiff_alltoall_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_ptrdiff_alltoall_warpiPlPKlm_nbst(shim_stream, shim_obj)


def bfloat16_alltoall_block():
    pass
    

def _lower__ZL32nvshmemx_bfloat16_alltoall_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_bfloat16_alltoall_blockiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems) {
        retval = nvshmemx_bfloat16_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL32nvshmemx_bfloat16_alltoall_blockiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL32nvshmemx_bfloat16_alltoall_blockiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_bfloat16_alltoall_blockiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_bfloat16_alltoall_blockiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_alltoall_block, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_bfloat16_alltoall_blockiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_bfloat16_alltoall_blockiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_bfloat16_alltoall_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_alltoall_block():
    pass
    

def _lower__ZL28nvshmemx_half_alltoall_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_half_alltoall_blockiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nelems) {
        retval = nvshmemx_half_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_half_alltoall_blockiP6__halfPKS_m_nbst = declare_device(
        '_ZL28nvshmemx_half_alltoall_blockiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_half_alltoall_blockiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_half_alltoall_blockiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_alltoall_block, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_half_alltoall_blockiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_half_alltoall_blockiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_half_alltoall_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_alltoall_block():
    pass
    

def _lower__ZL29nvshmemx_float_alltoall_blockiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_float_alltoall_blockiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nelems) {
        retval = nvshmemx_float_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_float_alltoall_blockiPfPKfm_nbst = declare_device(
        '_ZL29nvshmemx_float_alltoall_blockiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_float_alltoall_blockiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_float_alltoall_blockiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_alltoall_block, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_float_alltoall_blockiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_float_alltoall_blockiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_float_alltoall_blockiPfPKfm_nbst(shim_stream, shim_obj)


def double_alltoall_block():
    pass
    

def _lower__ZL30nvshmemx_double_alltoall_blockiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_double_alltoall_blockiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nelems) {
        retval = nvshmemx_double_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL30nvshmemx_double_alltoall_blockiPdPKdm_nbst = declare_device(
        '_ZL30nvshmemx_double_alltoall_blockiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_double_alltoall_blockiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_double_alltoall_blockiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_alltoall_block, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_double_alltoall_blockiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_double_alltoall_blockiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_double_alltoall_blockiPdPKdm_nbst(shim_stream, shim_obj)


def char_alltoall_block():
    pass
    

def _lower__ZL28nvshmemx_char_alltoall_blockiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_char_alltoall_blockiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nelems) {
        retval = nvshmemx_char_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_char_alltoall_blockiPcPKcm_nbst = declare_device(
        '_ZL28nvshmemx_char_alltoall_blockiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_char_alltoall_blockiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_char_alltoall_blockiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_alltoall_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_char_alltoall_blockiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_char_alltoall_blockiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_char_alltoall_blockiPcPKcm_nbst(shim_stream, shim_obj)


def short_alltoall_block():
    pass
    

def _lower__ZL29nvshmemx_short_alltoall_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_short_alltoall_blockiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nelems) {
        retval = nvshmemx_short_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_short_alltoall_blockiPsPKsm_nbst = declare_device(
        '_ZL29nvshmemx_short_alltoall_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_short_alltoall_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_short_alltoall_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_alltoall_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_short_alltoall_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_short_alltoall_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_short_alltoall_blockiPsPKsm_nbst(shim_stream, shim_obj)


def schar_alltoall_block():
    pass
    

def _lower__ZL29nvshmemx_schar_alltoall_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_schar_alltoall_blockiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nelems) {
        retval = nvshmemx_schar_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_schar_alltoall_blockiPaPKam_nbst = declare_device(
        '_ZL29nvshmemx_schar_alltoall_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_schar_alltoall_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_schar_alltoall_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_alltoall_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_schar_alltoall_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_schar_alltoall_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_schar_alltoall_blockiPaPKam_nbst(shim_stream, shim_obj)


def int_alltoall_block():
    pass
    

def _lower__ZL27nvshmemx_int_alltoall_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmemx_int_alltoall_blockiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nelems) {
        retval = nvshmemx_int_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL27nvshmemx_int_alltoall_blockiPiPKim_nbst = declare_device(
        '_ZL27nvshmemx_int_alltoall_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmemx_int_alltoall_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmemx_int_alltoall_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_alltoall_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmemx_int_alltoall_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmemx_int_alltoall_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmemx_int_alltoall_blockiPiPKim_nbst(shim_stream, shim_obj)


def long_alltoall_block():
    pass
    

def _lower__ZL28nvshmemx_long_alltoall_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_long_alltoall_blockiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nelems) {
        retval = nvshmemx_long_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_long_alltoall_blockiPlPKlm_nbst = declare_device(
        '_ZL28nvshmemx_long_alltoall_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_long_alltoall_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_long_alltoall_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_alltoall_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_long_alltoall_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_long_alltoall_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_long_alltoall_blockiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_alltoall_block():
    pass
    

def _lower__ZL32nvshmemx_longlong_alltoall_blockiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_longlong_alltoall_blockiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nelems) {
        retval = nvshmemx_longlong_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL32nvshmemx_longlong_alltoall_blockiPxPKxm_nbst = declare_device(
        '_ZL32nvshmemx_longlong_alltoall_blockiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_longlong_alltoall_blockiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_longlong_alltoall_blockiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_alltoall_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_longlong_alltoall_blockiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_longlong_alltoall_blockiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_longlong_alltoall_blockiPxPKxm_nbst(shim_stream, shim_obj)


def uchar_alltoall_block():
    pass
    

def _lower__ZL29nvshmemx_uchar_alltoall_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uchar_alltoall_blockiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nelems) {
        retval = nvshmemx_uchar_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_uchar_alltoall_blockiPhPKhm_nbst = declare_device(
        '_ZL29nvshmemx_uchar_alltoall_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_uchar_alltoall_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_uchar_alltoall_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_alltoall_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uchar_alltoall_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uchar_alltoall_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_uchar_alltoall_blockiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_alltoall_block():
    pass
    

def _lower__ZL30nvshmemx_ushort_alltoall_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_ushort_alltoall_blockiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nelems) {
        retval = nvshmemx_ushort_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL30nvshmemx_ushort_alltoall_blockiPtPKtm_nbst = declare_device(
        '_ZL30nvshmemx_ushort_alltoall_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_ushort_alltoall_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_ushort_alltoall_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_alltoall_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_ushort_alltoall_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_ushort_alltoall_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_ushort_alltoall_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint_alltoall_block():
    pass
    

def _lower__ZL28nvshmemx_uint_alltoall_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_uint_alltoall_blockiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nelems) {
        retval = nvshmemx_uint_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_uint_alltoall_blockiPjPKjm_nbst = declare_device(
        '_ZL28nvshmemx_uint_alltoall_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_uint_alltoall_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_uint_alltoall_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_alltoall_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_uint_alltoall_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_uint_alltoall_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_uint_alltoall_blockiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_alltoall_block():
    pass
    

def _lower__ZL29nvshmemx_ulong_alltoall_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_ulong_alltoall_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nelems) {
        retval = nvshmemx_ulong_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_ulong_alltoall_blockiPmPKmm_nbst = declare_device(
        '_ZL29nvshmemx_ulong_alltoall_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_ulong_alltoall_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_ulong_alltoall_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_alltoall_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_ulong_alltoall_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_ulong_alltoall_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_ulong_alltoall_blockiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_alltoall_block():
    pass
    

def _lower__ZL33nvshmemx_ulonglong_alltoall_blockiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmemx_ulonglong_alltoall_blockiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems) {
        retval = nvshmemx_ulonglong_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL33nvshmemx_ulonglong_alltoall_blockiPyPKym_nbst = declare_device(
        '_ZL33nvshmemx_ulonglong_alltoall_blockiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL33nvshmemx_ulonglong_alltoall_blockiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL33nvshmemx_ulonglong_alltoall_blockiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_alltoall_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmemx_ulonglong_alltoall_blockiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmemx_ulonglong_alltoall_blockiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL33nvshmemx_ulonglong_alltoall_blockiPyPKym_nbst(shim_stream, shim_obj)


def int8_alltoall_block():
    pass
    

def _lower__ZL28nvshmemx_int8_alltoall_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_int8_alltoall_blockiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nelems) {
        retval = nvshmemx_int8_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_int8_alltoall_blockiPaPKam_nbst = declare_device(
        '_ZL28nvshmemx_int8_alltoall_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_int8_alltoall_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_int8_alltoall_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_alltoall_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_int8_alltoall_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_int8_alltoall_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_int8_alltoall_blockiPaPKam_nbst(shim_stream, shim_obj)


def int16_alltoall_block():
    pass
    

def _lower__ZL29nvshmemx_int16_alltoall_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int16_alltoall_blockiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nelems) {
        retval = nvshmemx_int16_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_int16_alltoall_blockiPsPKsm_nbst = declare_device(
        '_ZL29nvshmemx_int16_alltoall_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_int16_alltoall_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_int16_alltoall_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_alltoall_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int16_alltoall_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int16_alltoall_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_int16_alltoall_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int32_alltoall_block():
    pass
    

def _lower__ZL29nvshmemx_int32_alltoall_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int32_alltoall_blockiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nelems) {
        retval = nvshmemx_int32_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_int32_alltoall_blockiPiPKim_nbst = declare_device(
        '_ZL29nvshmemx_int32_alltoall_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_int32_alltoall_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_int32_alltoall_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_alltoall_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int32_alltoall_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int32_alltoall_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_int32_alltoall_blockiPiPKim_nbst(shim_stream, shim_obj)


def int64_alltoall_block():
    pass
    

def _lower__ZL29nvshmemx_int64_alltoall_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int64_alltoall_blockiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nelems) {
        retval = nvshmemx_int64_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_int64_alltoall_blockiPlPKlm_nbst = declare_device(
        '_ZL29nvshmemx_int64_alltoall_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_int64_alltoall_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_int64_alltoall_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_alltoall_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int64_alltoall_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int64_alltoall_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_int64_alltoall_blockiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_alltoall_block():
    pass
    

def _lower__ZL29nvshmemx_uint8_alltoall_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uint8_alltoall_blockiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nelems) {
        retval = nvshmemx_uint8_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_uint8_alltoall_blockiPhPKhm_nbst = declare_device(
        '_ZL29nvshmemx_uint8_alltoall_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_uint8_alltoall_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_uint8_alltoall_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_alltoall_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uint8_alltoall_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uint8_alltoall_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_uint8_alltoall_blockiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_alltoall_block():
    pass
    

def _lower__ZL30nvshmemx_uint16_alltoall_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint16_alltoall_blockiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nelems) {
        retval = nvshmemx_uint16_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL30nvshmemx_uint16_alltoall_blockiPtPKtm_nbst = declare_device(
        '_ZL30nvshmemx_uint16_alltoall_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint16_alltoall_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint16_alltoall_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_alltoall_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint16_alltoall_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint16_alltoall_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint16_alltoall_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_alltoall_block():
    pass
    

def _lower__ZL30nvshmemx_uint32_alltoall_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint32_alltoall_blockiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nelems) {
        retval = nvshmemx_uint32_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL30nvshmemx_uint32_alltoall_blockiPjPKjm_nbst = declare_device(
        '_ZL30nvshmemx_uint32_alltoall_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint32_alltoall_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint32_alltoall_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_alltoall_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint32_alltoall_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint32_alltoall_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint32_alltoall_blockiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_alltoall_block():
    pass
    

def _lower__ZL30nvshmemx_uint64_alltoall_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint64_alltoall_blockiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nelems) {
        retval = nvshmemx_uint64_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL30nvshmemx_uint64_alltoall_blockiPmPKmm_nbst = declare_device(
        '_ZL30nvshmemx_uint64_alltoall_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint64_alltoall_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint64_alltoall_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_alltoall_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint64_alltoall_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint64_alltoall_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint64_alltoall_blockiPmPKmm_nbst(shim_stream, shim_obj)


def size_alltoall_block():
    pass
    

def _lower__ZL28nvshmemx_size_alltoall_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_size_alltoall_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nelems) {
        retval = nvshmemx_size_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_size_alltoall_blockiPmPKmm_nbst = declare_device(
        '_ZL28nvshmemx_size_alltoall_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_size_alltoall_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_size_alltoall_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_alltoall_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_size_alltoall_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_size_alltoall_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_size_alltoall_blockiPmPKmm_nbst(shim_stream, shim_obj)


def ptrdiff_alltoall_block():
    pass
    

def _lower__ZL31nvshmemx_ptrdiff_alltoall_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_ptrdiff_alltoall_blockiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nelems) {
        retval = nvshmemx_ptrdiff_alltoall_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL31nvshmemx_ptrdiff_alltoall_blockiPlPKlm_nbst = declare_device(
        '_ZL31nvshmemx_ptrdiff_alltoall_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_ptrdiff_alltoall_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_ptrdiff_alltoall_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ptrdiff_alltoall_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_ptrdiff_alltoall_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_ptrdiff_alltoall_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_ptrdiff_alltoall_blockiPlPKlm_nbst(shim_stream, shim_obj)


def barrier_warp():
    pass
    

def _lower__ZL21nvshmemx_barrier_warpi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL21nvshmemx_barrier_warpi_nbst(int &retval , int* team) {
        retval = nvshmemx_barrier_warp(*team);
        return 0;
    }
        """


    _ZL21nvshmemx_barrier_warpi_nbst = declare_device(
        '_ZL21nvshmemx_barrier_warpi_nbst',
        int32(
            CPointer(int32)
        )
    )
    

    def _ZL21nvshmemx_barrier_warpi_nbst_caller(arg_0):
        return _ZL21nvshmemx_barrier_warpi_nbst(arg_0)
    

    @lower(barrier_warp, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL21nvshmemx_barrier_warpi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL21nvshmemx_barrier_warpi_nbst_caller,
            signature(int32, CPointer(int32)),
            ptrs,
        )



_lower__ZL21nvshmemx_barrier_warpi_nbst(shim_stream, shim_obj)


def barrier_warpgroup():
    pass
    

def _lower__ZL26nvshmemx_barrier_warpgroupi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL26nvshmemx_barrier_warpgroupi_nbst(int &retval , int* team) {
        retval = nvshmemx_barrier_warpgroup(*team);
        return 0;
    }
        """


    _ZL26nvshmemx_barrier_warpgroupi_nbst = declare_device(
        '_ZL26nvshmemx_barrier_warpgroupi_nbst',
        int32(
            CPointer(int32)
        )
    )
    

    def _ZL26nvshmemx_barrier_warpgroupi_nbst_caller(arg_0):
        return _ZL26nvshmemx_barrier_warpgroupi_nbst(arg_0)
    

    @lower(barrier_warpgroup, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL26nvshmemx_barrier_warpgroupi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL26nvshmemx_barrier_warpgroupi_nbst_caller,
            signature(int32, CPointer(int32)),
            ptrs,
        )



_lower__ZL26nvshmemx_barrier_warpgroupi_nbst(shim_stream, shim_obj)


def barrier_block():
    pass
    

def _lower__ZL22nvshmemx_barrier_blocki_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmemx_barrier_blocki_nbst(int &retval , int* team) {
        retval = nvshmemx_barrier_block(*team);
        return 0;
    }
        """


    _ZL22nvshmemx_barrier_blocki_nbst = declare_device(
        '_ZL22nvshmemx_barrier_blocki_nbst',
        int32(
            CPointer(int32)
        )
    )
    

    def _ZL22nvshmemx_barrier_blocki_nbst_caller(arg_0):
        return _ZL22nvshmemx_barrier_blocki_nbst(arg_0)
    

    @lower(barrier_block, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmemx_barrier_blocki_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmemx_barrier_blocki_nbst_caller,
            signature(int32, CPointer(int32)),
            ptrs,
        )



_lower__ZL22nvshmemx_barrier_blocki_nbst(shim_stream, shim_obj)


def barrier_all_warp():
    pass
    

def _lower__ZL25nvshmemx_barrier_all_warpv_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmemx_barrier_all_warpv_nbst(int &retval ) {
        nvshmemx_barrier_all_warp();
        return 0;
    }
        """


    _ZL25nvshmemx_barrier_all_warpv_nbst = declare_device(
        '_ZL25nvshmemx_barrier_all_warpv_nbst',
        void(
        
        )
    )
    

    def _ZL25nvshmemx_barrier_all_warpv_nbst_caller():
        return _ZL25nvshmemx_barrier_all_warpv_nbst()
    

    @lower(barrier_all_warp, )
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmemx_barrier_all_warpv_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmemx_barrier_all_warpv_nbst_caller,
            signature(void, ),
            ptrs,
        )



_lower__ZL25nvshmemx_barrier_all_warpv_nbst(shim_stream, shim_obj)


def barrier_all_block():
    pass
    

def _lower__ZL26nvshmemx_barrier_all_blockv_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL26nvshmemx_barrier_all_blockv_nbst(int &retval ) {
        nvshmemx_barrier_all_block();
        return 0;
    }
        """


    _ZL26nvshmemx_barrier_all_blockv_nbst = declare_device(
        '_ZL26nvshmemx_barrier_all_blockv_nbst',
        void(
        
        )
    )
    

    def _ZL26nvshmemx_barrier_all_blockv_nbst_caller():
        return _ZL26nvshmemx_barrier_all_blockv_nbst()
    

    @lower(barrier_all_block, )
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL26nvshmemx_barrier_all_blockv_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL26nvshmemx_barrier_all_blockv_nbst_caller,
            signature(void, ),
            ptrs,
        )



_lower__ZL26nvshmemx_barrier_all_blockv_nbst(shim_stream, shim_obj)


def team_sync_warp():
    pass
    

def _lower__ZL23nvshmemx_team_sync_warpi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmemx_team_sync_warpi_nbst(int &retval , int* team) {
        retval = nvshmemx_team_sync_warp(*team);
        return 0;
    }
        """


    _ZL23nvshmemx_team_sync_warpi_nbst = declare_device(
        '_ZL23nvshmemx_team_sync_warpi_nbst',
        int32(
            CPointer(int32)
        )
    )
    

    def _ZL23nvshmemx_team_sync_warpi_nbst_caller(arg_0):
        return _ZL23nvshmemx_team_sync_warpi_nbst(arg_0)
    

    @lower(team_sync_warp, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmemx_team_sync_warpi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmemx_team_sync_warpi_nbst_caller,
            signature(int32, CPointer(int32)),
            ptrs,
        )



_lower__ZL23nvshmemx_team_sync_warpi_nbst(shim_stream, shim_obj)


def team_sync_block():
    pass
    

def _lower__ZL24nvshmemx_team_sync_blocki_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL24nvshmemx_team_sync_blocki_nbst(int &retval , int* team) {
        retval = nvshmemx_team_sync_block(*team);
        return 0;
    }
        """


    _ZL24nvshmemx_team_sync_blocki_nbst = declare_device(
        '_ZL24nvshmemx_team_sync_blocki_nbst',
        int32(
            CPointer(int32)
        )
    )
    

    def _ZL24nvshmemx_team_sync_blocki_nbst_caller(arg_0):
        return _ZL24nvshmemx_team_sync_blocki_nbst(arg_0)
    

    @lower(team_sync_block, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL24nvshmemx_team_sync_blocki_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL24nvshmemx_team_sync_blocki_nbst_caller,
            signature(int32, CPointer(int32)),
            ptrs,
        )



_lower__ZL24nvshmemx_team_sync_blocki_nbst(shim_stream, shim_obj)


def sync_all_warp():
    pass
    

def _lower__ZL22nvshmemx_sync_all_warpv_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL22nvshmemx_sync_all_warpv_nbst(int &retval ) {
        nvshmemx_sync_all_warp();
        return 0;
    }
        """


    _ZL22nvshmemx_sync_all_warpv_nbst = declare_device(
        '_ZL22nvshmemx_sync_all_warpv_nbst',
        void(
        
        )
    )
    

    def _ZL22nvshmemx_sync_all_warpv_nbst_caller():
        return _ZL22nvshmemx_sync_all_warpv_nbst()
    

    @lower(sync_all_warp, )
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL22nvshmemx_sync_all_warpv_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL22nvshmemx_sync_all_warpv_nbst_caller,
            signature(void, ),
            ptrs,
        )



_lower__ZL22nvshmemx_sync_all_warpv_nbst(shim_stream, shim_obj)


def sync_all_block():
    pass
    

def _lower__ZL23nvshmemx_sync_all_blockv_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL23nvshmemx_sync_all_blockv_nbst(int &retval ) {
        nvshmemx_sync_all_block();
        return 0;
    }
        """


    _ZL23nvshmemx_sync_all_blockv_nbst = declare_device(
        '_ZL23nvshmemx_sync_all_blockv_nbst',
        void(
        
        )
    )
    

    def _ZL23nvshmemx_sync_all_blockv_nbst_caller():
        return _ZL23nvshmemx_sync_all_blockv_nbst()
    

    @lower(sync_all_block, )
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL23nvshmemx_sync_all_blockv_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL23nvshmemx_sync_all_blockv_nbst_caller,
            signature(void, ),
            ptrs,
        )



_lower__ZL23nvshmemx_sync_all_blockv_nbst(shim_stream, shim_obj)


def broadcastmem_warp():
    pass
    

def _lower__ZL26nvshmemx_broadcastmem_warpiPvPKvmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL26nvshmemx_broadcastmem_warpiPvPKvmi_nbst(int &retval , int* team, void ** dest, void ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_broadcastmem_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL26nvshmemx_broadcastmem_warpiPvPKvmi_nbst = declare_device(
        '_ZL26nvshmemx_broadcastmem_warpiPvPKvmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL26nvshmemx_broadcastmem_warpiPvPKvmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL26nvshmemx_broadcastmem_warpiPvPKvmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(broadcastmem_warp, int32, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL26nvshmemx_broadcastmem_warpiPvPKvmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL26nvshmemx_broadcastmem_warpiPvPKvmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL26nvshmemx_broadcastmem_warpiPvPKvmi_nbst(shim_stream, shim_obj)


def broadcastmem_block():
    pass
    

def _lower__ZL27nvshmemx_broadcastmem_blockiPvPKvmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmemx_broadcastmem_blockiPvPKvmi_nbst(int &retval , int* team, void ** dest, void ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_broadcastmem_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL27nvshmemx_broadcastmem_blockiPvPKvmi_nbst = declare_device(
        '_ZL27nvshmemx_broadcastmem_blockiPvPKvmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL27nvshmemx_broadcastmem_blockiPvPKvmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL27nvshmemx_broadcastmem_blockiPvPKvmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(broadcastmem_block, int32, CPointer(void), CPointer(void), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmemx_broadcastmem_blockiPvPKvmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmemx_broadcastmem_blockiPvPKvmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL27nvshmemx_broadcastmem_blockiPvPKvmi_nbst(shim_stream, shim_obj)


def bfloat16_broadcast_warp():
    pass
    

def _lower__ZL32nvshmemx_bfloat16_broadcast_warpiP13__nv_bfloat16PKS_mi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_bfloat16_broadcast_warpiP13__nv_bfloat16PKS_mi_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_bfloat16_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL32nvshmemx_bfloat16_broadcast_warpiP13__nv_bfloat16PKS_mi_nbst = declare_device(
        '_ZL32nvshmemx_bfloat16_broadcast_warpiP13__nv_bfloat16PKS_mi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL32nvshmemx_bfloat16_broadcast_warpiP13__nv_bfloat16PKS_mi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL32nvshmemx_bfloat16_broadcast_warpiP13__nv_bfloat16PKS_mi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(bfloat16_broadcast_warp, int32, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_bfloat16_broadcast_warpiP13__nv_bfloat16PKS_mi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_bfloat16_broadcast_warpiP13__nv_bfloat16PKS_mi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL32nvshmemx_bfloat16_broadcast_warpiP13__nv_bfloat16PKS_mi_nbst(shim_stream, shim_obj)


def half_broadcast_warp():
    pass
    

def _lower__ZL28nvshmemx_half_broadcast_warpiP6__halfPKS_mi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_half_broadcast_warpiP6__halfPKS_mi_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_half_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL28nvshmemx_half_broadcast_warpiP6__halfPKS_mi_nbst = declare_device(
        '_ZL28nvshmemx_half_broadcast_warpiP6__halfPKS_mi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL28nvshmemx_half_broadcast_warpiP6__halfPKS_mi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL28nvshmemx_half_broadcast_warpiP6__halfPKS_mi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(half_broadcast_warp, int32, CPointer(float16), CPointer(float16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_half_broadcast_warpiP6__halfPKS_mi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_half_broadcast_warpiP6__halfPKS_mi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL28nvshmemx_half_broadcast_warpiP6__halfPKS_mi_nbst(shim_stream, shim_obj)


def float_broadcast_warp():
    pass
    

def _lower__ZL29nvshmemx_float_broadcast_warpiPfPKfmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_float_broadcast_warpiPfPKfmi_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_float_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL29nvshmemx_float_broadcast_warpiPfPKfmi_nbst = declare_device(
        '_ZL29nvshmemx_float_broadcast_warpiPfPKfmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL29nvshmemx_float_broadcast_warpiPfPKfmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL29nvshmemx_float_broadcast_warpiPfPKfmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(float_broadcast_warp, int32, CPointer(float32), CPointer(float32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_float_broadcast_warpiPfPKfmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_float_broadcast_warpiPfPKfmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL29nvshmemx_float_broadcast_warpiPfPKfmi_nbst(shim_stream, shim_obj)


def double_broadcast_warp():
    pass
    

def _lower__ZL30nvshmemx_double_broadcast_warpiPdPKdmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_double_broadcast_warpiPdPKdmi_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_double_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL30nvshmemx_double_broadcast_warpiPdPKdmi_nbst = declare_device(
        '_ZL30nvshmemx_double_broadcast_warpiPdPKdmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL30nvshmemx_double_broadcast_warpiPdPKdmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL30nvshmemx_double_broadcast_warpiPdPKdmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(double_broadcast_warp, int32, CPointer(float64), CPointer(float64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_double_broadcast_warpiPdPKdmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_double_broadcast_warpiPdPKdmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL30nvshmemx_double_broadcast_warpiPdPKdmi_nbst(shim_stream, shim_obj)


def char_broadcast_warp():
    pass
    

def _lower__ZL28nvshmemx_char_broadcast_warpiPcPKcmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_char_broadcast_warpiPcPKcmi_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_char_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL28nvshmemx_char_broadcast_warpiPcPKcmi_nbst = declare_device(
        '_ZL28nvshmemx_char_broadcast_warpiPcPKcmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL28nvshmemx_char_broadcast_warpiPcPKcmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL28nvshmemx_char_broadcast_warpiPcPKcmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(char_broadcast_warp, int32, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_char_broadcast_warpiPcPKcmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_char_broadcast_warpiPcPKcmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL28nvshmemx_char_broadcast_warpiPcPKcmi_nbst(shim_stream, shim_obj)


def short_broadcast_warp():
    pass
    

def _lower__ZL29nvshmemx_short_broadcast_warpiPsPKsmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_short_broadcast_warpiPsPKsmi_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_short_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL29nvshmemx_short_broadcast_warpiPsPKsmi_nbst = declare_device(
        '_ZL29nvshmemx_short_broadcast_warpiPsPKsmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL29nvshmemx_short_broadcast_warpiPsPKsmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL29nvshmemx_short_broadcast_warpiPsPKsmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(short_broadcast_warp, int32, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_short_broadcast_warpiPsPKsmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_short_broadcast_warpiPsPKsmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL29nvshmemx_short_broadcast_warpiPsPKsmi_nbst(shim_stream, shim_obj)


def schar_broadcast_warp():
    pass
    

def _lower__ZL29nvshmemx_schar_broadcast_warpiPaPKami_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_schar_broadcast_warpiPaPKami_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_schar_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL29nvshmemx_schar_broadcast_warpiPaPKami_nbst = declare_device(
        '_ZL29nvshmemx_schar_broadcast_warpiPaPKami_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL29nvshmemx_schar_broadcast_warpiPaPKami_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL29nvshmemx_schar_broadcast_warpiPaPKami_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(schar_broadcast_warp, int32, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_schar_broadcast_warpiPaPKami_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_schar_broadcast_warpiPaPKami_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL29nvshmemx_schar_broadcast_warpiPaPKami_nbst(shim_stream, shim_obj)


def int_broadcast_warp():
    pass
    

def _lower__ZL27nvshmemx_int_broadcast_warpiPiPKimi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmemx_int_broadcast_warpiPiPKimi_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_int_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL27nvshmemx_int_broadcast_warpiPiPKimi_nbst = declare_device(
        '_ZL27nvshmemx_int_broadcast_warpiPiPKimi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL27nvshmemx_int_broadcast_warpiPiPKimi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL27nvshmemx_int_broadcast_warpiPiPKimi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int_broadcast_warp, int32, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmemx_int_broadcast_warpiPiPKimi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmemx_int_broadcast_warpiPiPKimi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL27nvshmemx_int_broadcast_warpiPiPKimi_nbst(shim_stream, shim_obj)


def long_broadcast_warp():
    pass
    

def _lower__ZL28nvshmemx_long_broadcast_warpiPlPKlmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_long_broadcast_warpiPlPKlmi_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_long_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL28nvshmemx_long_broadcast_warpiPlPKlmi_nbst = declare_device(
        '_ZL28nvshmemx_long_broadcast_warpiPlPKlmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL28nvshmemx_long_broadcast_warpiPlPKlmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL28nvshmemx_long_broadcast_warpiPlPKlmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(long_broadcast_warp, int32, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_long_broadcast_warpiPlPKlmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_long_broadcast_warpiPlPKlmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL28nvshmemx_long_broadcast_warpiPlPKlmi_nbst(shim_stream, shim_obj)


def longlong_broadcast_warp():
    pass
    

def _lower__ZL32nvshmemx_longlong_broadcast_warpiPxPKxmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_longlong_broadcast_warpiPxPKxmi_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_longlong_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL32nvshmemx_longlong_broadcast_warpiPxPKxmi_nbst = declare_device(
        '_ZL32nvshmemx_longlong_broadcast_warpiPxPKxmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL32nvshmemx_longlong_broadcast_warpiPxPKxmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL32nvshmemx_longlong_broadcast_warpiPxPKxmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(longlong_broadcast_warp, int32, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_longlong_broadcast_warpiPxPKxmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_longlong_broadcast_warpiPxPKxmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL32nvshmemx_longlong_broadcast_warpiPxPKxmi_nbst(shim_stream, shim_obj)


def uchar_broadcast_warp():
    pass
    

def _lower__ZL29nvshmemx_uchar_broadcast_warpiPhPKhmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uchar_broadcast_warpiPhPKhmi_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_uchar_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL29nvshmemx_uchar_broadcast_warpiPhPKhmi_nbst = declare_device(
        '_ZL29nvshmemx_uchar_broadcast_warpiPhPKhmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL29nvshmemx_uchar_broadcast_warpiPhPKhmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL29nvshmemx_uchar_broadcast_warpiPhPKhmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uchar_broadcast_warp, int32, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uchar_broadcast_warpiPhPKhmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uchar_broadcast_warpiPhPKhmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL29nvshmemx_uchar_broadcast_warpiPhPKhmi_nbst(shim_stream, shim_obj)


def ushort_broadcast_warp():
    pass
    

def _lower__ZL30nvshmemx_ushort_broadcast_warpiPtPKtmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_ushort_broadcast_warpiPtPKtmi_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_ushort_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL30nvshmemx_ushort_broadcast_warpiPtPKtmi_nbst = declare_device(
        '_ZL30nvshmemx_ushort_broadcast_warpiPtPKtmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL30nvshmemx_ushort_broadcast_warpiPtPKtmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL30nvshmemx_ushort_broadcast_warpiPtPKtmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ushort_broadcast_warp, int32, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_ushort_broadcast_warpiPtPKtmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_ushort_broadcast_warpiPtPKtmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL30nvshmemx_ushort_broadcast_warpiPtPKtmi_nbst(shim_stream, shim_obj)


def uint_broadcast_warp():
    pass
    

def _lower__ZL28nvshmemx_uint_broadcast_warpiPjPKjmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_uint_broadcast_warpiPjPKjmi_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_uint_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL28nvshmemx_uint_broadcast_warpiPjPKjmi_nbst = declare_device(
        '_ZL28nvshmemx_uint_broadcast_warpiPjPKjmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL28nvshmemx_uint_broadcast_warpiPjPKjmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL28nvshmemx_uint_broadcast_warpiPjPKjmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint_broadcast_warp, int32, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_uint_broadcast_warpiPjPKjmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_uint_broadcast_warpiPjPKjmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL28nvshmemx_uint_broadcast_warpiPjPKjmi_nbst(shim_stream, shim_obj)


def ulong_broadcast_warp():
    pass
    

def _lower__ZL29nvshmemx_ulong_broadcast_warpiPmPKmmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_ulong_broadcast_warpiPmPKmmi_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_ulong_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL29nvshmemx_ulong_broadcast_warpiPmPKmmi_nbst = declare_device(
        '_ZL29nvshmemx_ulong_broadcast_warpiPmPKmmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL29nvshmemx_ulong_broadcast_warpiPmPKmmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL29nvshmemx_ulong_broadcast_warpiPmPKmmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulong_broadcast_warp, int32, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_ulong_broadcast_warpiPmPKmmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_ulong_broadcast_warpiPmPKmmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL29nvshmemx_ulong_broadcast_warpiPmPKmmi_nbst(shim_stream, shim_obj)


def ulonglong_broadcast_warp():
    pass
    

def _lower__ZL33nvshmemx_ulonglong_broadcast_warpiPyPKymi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmemx_ulonglong_broadcast_warpiPyPKymi_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_ulonglong_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL33nvshmemx_ulonglong_broadcast_warpiPyPKymi_nbst = declare_device(
        '_ZL33nvshmemx_ulonglong_broadcast_warpiPyPKymi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL33nvshmemx_ulonglong_broadcast_warpiPyPKymi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL33nvshmemx_ulonglong_broadcast_warpiPyPKymi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulonglong_broadcast_warp, int32, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmemx_ulonglong_broadcast_warpiPyPKymi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmemx_ulonglong_broadcast_warpiPyPKymi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL33nvshmemx_ulonglong_broadcast_warpiPyPKymi_nbst(shim_stream, shim_obj)


def int8_broadcast_warp():
    pass
    

def _lower__ZL28nvshmemx_int8_broadcast_warpiPaPKami_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_int8_broadcast_warpiPaPKami_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_int8_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL28nvshmemx_int8_broadcast_warpiPaPKami_nbst = declare_device(
        '_ZL28nvshmemx_int8_broadcast_warpiPaPKami_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL28nvshmemx_int8_broadcast_warpiPaPKami_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL28nvshmemx_int8_broadcast_warpiPaPKami_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int8_broadcast_warp, int32, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_int8_broadcast_warpiPaPKami_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_int8_broadcast_warpiPaPKami_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL28nvshmemx_int8_broadcast_warpiPaPKami_nbst(shim_stream, shim_obj)


def int16_broadcast_warp():
    pass
    

def _lower__ZL29nvshmemx_int16_broadcast_warpiPsPKsmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int16_broadcast_warpiPsPKsmi_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_int16_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL29nvshmemx_int16_broadcast_warpiPsPKsmi_nbst = declare_device(
        '_ZL29nvshmemx_int16_broadcast_warpiPsPKsmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL29nvshmemx_int16_broadcast_warpiPsPKsmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL29nvshmemx_int16_broadcast_warpiPsPKsmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int16_broadcast_warp, int32, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int16_broadcast_warpiPsPKsmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int16_broadcast_warpiPsPKsmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL29nvshmemx_int16_broadcast_warpiPsPKsmi_nbst(shim_stream, shim_obj)


def int32_broadcast_warp():
    pass
    

def _lower__ZL29nvshmemx_int32_broadcast_warpiPiPKimi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int32_broadcast_warpiPiPKimi_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_int32_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL29nvshmemx_int32_broadcast_warpiPiPKimi_nbst = declare_device(
        '_ZL29nvshmemx_int32_broadcast_warpiPiPKimi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL29nvshmemx_int32_broadcast_warpiPiPKimi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL29nvshmemx_int32_broadcast_warpiPiPKimi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int32_broadcast_warp, int32, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int32_broadcast_warpiPiPKimi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int32_broadcast_warpiPiPKimi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL29nvshmemx_int32_broadcast_warpiPiPKimi_nbst(shim_stream, shim_obj)


def int64_broadcast_warp():
    pass
    

def _lower__ZL29nvshmemx_int64_broadcast_warpiPlPKlmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int64_broadcast_warpiPlPKlmi_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_int64_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL29nvshmemx_int64_broadcast_warpiPlPKlmi_nbst = declare_device(
        '_ZL29nvshmemx_int64_broadcast_warpiPlPKlmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL29nvshmemx_int64_broadcast_warpiPlPKlmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL29nvshmemx_int64_broadcast_warpiPlPKlmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int64_broadcast_warp, int32, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int64_broadcast_warpiPlPKlmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int64_broadcast_warpiPlPKlmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL29nvshmemx_int64_broadcast_warpiPlPKlmi_nbst(shim_stream, shim_obj)


def uint8_broadcast_warp():
    pass
    

def _lower__ZL29nvshmemx_uint8_broadcast_warpiPhPKhmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uint8_broadcast_warpiPhPKhmi_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_uint8_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL29nvshmemx_uint8_broadcast_warpiPhPKhmi_nbst = declare_device(
        '_ZL29nvshmemx_uint8_broadcast_warpiPhPKhmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL29nvshmemx_uint8_broadcast_warpiPhPKhmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL29nvshmemx_uint8_broadcast_warpiPhPKhmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint8_broadcast_warp, int32, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uint8_broadcast_warpiPhPKhmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uint8_broadcast_warpiPhPKhmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL29nvshmemx_uint8_broadcast_warpiPhPKhmi_nbst(shim_stream, shim_obj)


def uint16_broadcast_warp():
    pass
    

def _lower__ZL30nvshmemx_uint16_broadcast_warpiPtPKtmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint16_broadcast_warpiPtPKtmi_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_uint16_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL30nvshmemx_uint16_broadcast_warpiPtPKtmi_nbst = declare_device(
        '_ZL30nvshmemx_uint16_broadcast_warpiPtPKtmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL30nvshmemx_uint16_broadcast_warpiPtPKtmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL30nvshmemx_uint16_broadcast_warpiPtPKtmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint16_broadcast_warp, int32, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint16_broadcast_warpiPtPKtmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint16_broadcast_warpiPtPKtmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint16_broadcast_warpiPtPKtmi_nbst(shim_stream, shim_obj)


def uint32_broadcast_warp():
    pass
    

def _lower__ZL30nvshmemx_uint32_broadcast_warpiPjPKjmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint32_broadcast_warpiPjPKjmi_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_uint32_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL30nvshmemx_uint32_broadcast_warpiPjPKjmi_nbst = declare_device(
        '_ZL30nvshmemx_uint32_broadcast_warpiPjPKjmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL30nvshmemx_uint32_broadcast_warpiPjPKjmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL30nvshmemx_uint32_broadcast_warpiPjPKjmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint32_broadcast_warp, int32, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint32_broadcast_warpiPjPKjmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint32_broadcast_warpiPjPKjmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint32_broadcast_warpiPjPKjmi_nbst(shim_stream, shim_obj)


def uint64_broadcast_warp():
    pass
    

def _lower__ZL30nvshmemx_uint64_broadcast_warpiPmPKmmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint64_broadcast_warpiPmPKmmi_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_uint64_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL30nvshmemx_uint64_broadcast_warpiPmPKmmi_nbst = declare_device(
        '_ZL30nvshmemx_uint64_broadcast_warpiPmPKmmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL30nvshmemx_uint64_broadcast_warpiPmPKmmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL30nvshmemx_uint64_broadcast_warpiPmPKmmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint64_broadcast_warp, int32, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint64_broadcast_warpiPmPKmmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint64_broadcast_warpiPmPKmmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint64_broadcast_warpiPmPKmmi_nbst(shim_stream, shim_obj)


def size_broadcast_warp():
    pass
    

def _lower__ZL28nvshmemx_size_broadcast_warpiPmPKmmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_size_broadcast_warpiPmPKmmi_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_size_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL28nvshmemx_size_broadcast_warpiPmPKmmi_nbst = declare_device(
        '_ZL28nvshmemx_size_broadcast_warpiPmPKmmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL28nvshmemx_size_broadcast_warpiPmPKmmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL28nvshmemx_size_broadcast_warpiPmPKmmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(size_broadcast_warp, int32, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_size_broadcast_warpiPmPKmmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_size_broadcast_warpiPmPKmmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL28nvshmemx_size_broadcast_warpiPmPKmmi_nbst(shim_stream, shim_obj)


def ptrdiff_broadcast_warp():
    pass
    

def _lower__ZL31nvshmemx_ptrdiff_broadcast_warpiPlPKlmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_ptrdiff_broadcast_warpiPlPKlmi_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_ptrdiff_broadcast_warp(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL31nvshmemx_ptrdiff_broadcast_warpiPlPKlmi_nbst = declare_device(
        '_ZL31nvshmemx_ptrdiff_broadcast_warpiPlPKlmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL31nvshmemx_ptrdiff_broadcast_warpiPlPKlmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL31nvshmemx_ptrdiff_broadcast_warpiPlPKlmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ptrdiff_broadcast_warp, int32, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_ptrdiff_broadcast_warpiPlPKlmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_ptrdiff_broadcast_warpiPlPKlmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL31nvshmemx_ptrdiff_broadcast_warpiPlPKlmi_nbst(shim_stream, shim_obj)


def bfloat16_broadcast_block():
    pass
    

def _lower__ZL33nvshmemx_bfloat16_broadcast_blockiP13__nv_bfloat16PKS_mi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmemx_bfloat16_broadcast_blockiP13__nv_bfloat16PKS_mi_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_bfloat16_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL33nvshmemx_bfloat16_broadcast_blockiP13__nv_bfloat16PKS_mi_nbst = declare_device(
        '_ZL33nvshmemx_bfloat16_broadcast_blockiP13__nv_bfloat16PKS_mi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL33nvshmemx_bfloat16_broadcast_blockiP13__nv_bfloat16PKS_mi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL33nvshmemx_bfloat16_broadcast_blockiP13__nv_bfloat16PKS_mi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(bfloat16_broadcast_block, int32, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmemx_bfloat16_broadcast_blockiP13__nv_bfloat16PKS_mi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmemx_bfloat16_broadcast_blockiP13__nv_bfloat16PKS_mi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL33nvshmemx_bfloat16_broadcast_blockiP13__nv_bfloat16PKS_mi_nbst(shim_stream, shim_obj)


def half_broadcast_block():
    pass
    

def _lower__ZL29nvshmemx_half_broadcast_blockiP6__halfPKS_mi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_half_broadcast_blockiP6__halfPKS_mi_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_half_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL29nvshmemx_half_broadcast_blockiP6__halfPKS_mi_nbst = declare_device(
        '_ZL29nvshmemx_half_broadcast_blockiP6__halfPKS_mi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL29nvshmemx_half_broadcast_blockiP6__halfPKS_mi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL29nvshmemx_half_broadcast_blockiP6__halfPKS_mi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(half_broadcast_block, int32, CPointer(float16), CPointer(float16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_half_broadcast_blockiP6__halfPKS_mi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_half_broadcast_blockiP6__halfPKS_mi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL29nvshmemx_half_broadcast_blockiP6__halfPKS_mi_nbst(shim_stream, shim_obj)


def float_broadcast_block():
    pass
    

def _lower__ZL30nvshmemx_float_broadcast_blockiPfPKfmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_float_broadcast_blockiPfPKfmi_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_float_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL30nvshmemx_float_broadcast_blockiPfPKfmi_nbst = declare_device(
        '_ZL30nvshmemx_float_broadcast_blockiPfPKfmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL30nvshmemx_float_broadcast_blockiPfPKfmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL30nvshmemx_float_broadcast_blockiPfPKfmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(float_broadcast_block, int32, CPointer(float32), CPointer(float32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_float_broadcast_blockiPfPKfmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_float_broadcast_blockiPfPKfmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL30nvshmemx_float_broadcast_blockiPfPKfmi_nbst(shim_stream, shim_obj)


def double_broadcast_block():
    pass
    

def _lower__ZL31nvshmemx_double_broadcast_blockiPdPKdmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_double_broadcast_blockiPdPKdmi_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_double_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL31nvshmemx_double_broadcast_blockiPdPKdmi_nbst = declare_device(
        '_ZL31nvshmemx_double_broadcast_blockiPdPKdmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL31nvshmemx_double_broadcast_blockiPdPKdmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL31nvshmemx_double_broadcast_blockiPdPKdmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(double_broadcast_block, int32, CPointer(float64), CPointer(float64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_double_broadcast_blockiPdPKdmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_double_broadcast_blockiPdPKdmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL31nvshmemx_double_broadcast_blockiPdPKdmi_nbst(shim_stream, shim_obj)


def char_broadcast_block():
    pass
    

def _lower__ZL29nvshmemx_char_broadcast_blockiPcPKcmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_char_broadcast_blockiPcPKcmi_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_char_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL29nvshmemx_char_broadcast_blockiPcPKcmi_nbst = declare_device(
        '_ZL29nvshmemx_char_broadcast_blockiPcPKcmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL29nvshmemx_char_broadcast_blockiPcPKcmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL29nvshmemx_char_broadcast_blockiPcPKcmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(char_broadcast_block, int32, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_char_broadcast_blockiPcPKcmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_char_broadcast_blockiPcPKcmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL29nvshmemx_char_broadcast_blockiPcPKcmi_nbst(shim_stream, shim_obj)


def short_broadcast_block():
    pass
    

def _lower__ZL30nvshmemx_short_broadcast_blockiPsPKsmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_short_broadcast_blockiPsPKsmi_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_short_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL30nvshmemx_short_broadcast_blockiPsPKsmi_nbst = declare_device(
        '_ZL30nvshmemx_short_broadcast_blockiPsPKsmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL30nvshmemx_short_broadcast_blockiPsPKsmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL30nvshmemx_short_broadcast_blockiPsPKsmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(short_broadcast_block, int32, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_short_broadcast_blockiPsPKsmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_short_broadcast_blockiPsPKsmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL30nvshmemx_short_broadcast_blockiPsPKsmi_nbst(shim_stream, shim_obj)


def schar_broadcast_block():
    pass
    

def _lower__ZL30nvshmemx_schar_broadcast_blockiPaPKami_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_schar_broadcast_blockiPaPKami_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_schar_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL30nvshmemx_schar_broadcast_blockiPaPKami_nbst = declare_device(
        '_ZL30nvshmemx_schar_broadcast_blockiPaPKami_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL30nvshmemx_schar_broadcast_blockiPaPKami_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL30nvshmemx_schar_broadcast_blockiPaPKami_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(schar_broadcast_block, int32, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_schar_broadcast_blockiPaPKami_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_schar_broadcast_blockiPaPKami_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL30nvshmemx_schar_broadcast_blockiPaPKami_nbst(shim_stream, shim_obj)


def int_broadcast_block():
    pass
    

def _lower__ZL28nvshmemx_int_broadcast_blockiPiPKimi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_int_broadcast_blockiPiPKimi_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_int_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL28nvshmemx_int_broadcast_blockiPiPKimi_nbst = declare_device(
        '_ZL28nvshmemx_int_broadcast_blockiPiPKimi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL28nvshmemx_int_broadcast_blockiPiPKimi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL28nvshmemx_int_broadcast_blockiPiPKimi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int_broadcast_block, int32, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_int_broadcast_blockiPiPKimi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_int_broadcast_blockiPiPKimi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL28nvshmemx_int_broadcast_blockiPiPKimi_nbst(shim_stream, shim_obj)


def long_broadcast_block():
    pass
    

def _lower__ZL29nvshmemx_long_broadcast_blockiPlPKlmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_long_broadcast_blockiPlPKlmi_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_long_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL29nvshmemx_long_broadcast_blockiPlPKlmi_nbst = declare_device(
        '_ZL29nvshmemx_long_broadcast_blockiPlPKlmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL29nvshmemx_long_broadcast_blockiPlPKlmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL29nvshmemx_long_broadcast_blockiPlPKlmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(long_broadcast_block, int32, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_long_broadcast_blockiPlPKlmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_long_broadcast_blockiPlPKlmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL29nvshmemx_long_broadcast_blockiPlPKlmi_nbst(shim_stream, shim_obj)


def longlong_broadcast_block():
    pass
    

def _lower__ZL33nvshmemx_longlong_broadcast_blockiPxPKxmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmemx_longlong_broadcast_blockiPxPKxmi_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_longlong_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL33nvshmemx_longlong_broadcast_blockiPxPKxmi_nbst = declare_device(
        '_ZL33nvshmemx_longlong_broadcast_blockiPxPKxmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL33nvshmemx_longlong_broadcast_blockiPxPKxmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL33nvshmemx_longlong_broadcast_blockiPxPKxmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(longlong_broadcast_block, int32, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmemx_longlong_broadcast_blockiPxPKxmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmemx_longlong_broadcast_blockiPxPKxmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL33nvshmemx_longlong_broadcast_blockiPxPKxmi_nbst(shim_stream, shim_obj)


def uchar_broadcast_block():
    pass
    

def _lower__ZL30nvshmemx_uchar_broadcast_blockiPhPKhmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uchar_broadcast_blockiPhPKhmi_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_uchar_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL30nvshmemx_uchar_broadcast_blockiPhPKhmi_nbst = declare_device(
        '_ZL30nvshmemx_uchar_broadcast_blockiPhPKhmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL30nvshmemx_uchar_broadcast_blockiPhPKhmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL30nvshmemx_uchar_broadcast_blockiPhPKhmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uchar_broadcast_block, int32, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uchar_broadcast_blockiPhPKhmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uchar_broadcast_blockiPhPKhmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL30nvshmemx_uchar_broadcast_blockiPhPKhmi_nbst(shim_stream, shim_obj)


def ushort_broadcast_block():
    pass
    

def _lower__ZL31nvshmemx_ushort_broadcast_blockiPtPKtmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_ushort_broadcast_blockiPtPKtmi_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_ushort_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL31nvshmemx_ushort_broadcast_blockiPtPKtmi_nbst = declare_device(
        '_ZL31nvshmemx_ushort_broadcast_blockiPtPKtmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL31nvshmemx_ushort_broadcast_blockiPtPKtmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL31nvshmemx_ushort_broadcast_blockiPtPKtmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ushort_broadcast_block, int32, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_ushort_broadcast_blockiPtPKtmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_ushort_broadcast_blockiPtPKtmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL31nvshmemx_ushort_broadcast_blockiPtPKtmi_nbst(shim_stream, shim_obj)


def uint_broadcast_block():
    pass
    

def _lower__ZL29nvshmemx_uint_broadcast_blockiPjPKjmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uint_broadcast_blockiPjPKjmi_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_uint_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL29nvshmemx_uint_broadcast_blockiPjPKjmi_nbst = declare_device(
        '_ZL29nvshmemx_uint_broadcast_blockiPjPKjmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL29nvshmemx_uint_broadcast_blockiPjPKjmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL29nvshmemx_uint_broadcast_blockiPjPKjmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint_broadcast_block, int32, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uint_broadcast_blockiPjPKjmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uint_broadcast_blockiPjPKjmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL29nvshmemx_uint_broadcast_blockiPjPKjmi_nbst(shim_stream, shim_obj)


def ulong_broadcast_block():
    pass
    

def _lower__ZL30nvshmemx_ulong_broadcast_blockiPmPKmmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_ulong_broadcast_blockiPmPKmmi_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_ulong_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL30nvshmemx_ulong_broadcast_blockiPmPKmmi_nbst = declare_device(
        '_ZL30nvshmemx_ulong_broadcast_blockiPmPKmmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL30nvshmemx_ulong_broadcast_blockiPmPKmmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL30nvshmemx_ulong_broadcast_blockiPmPKmmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulong_broadcast_block, int32, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_ulong_broadcast_blockiPmPKmmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_ulong_broadcast_blockiPmPKmmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL30nvshmemx_ulong_broadcast_blockiPmPKmmi_nbst(shim_stream, shim_obj)


def ulonglong_broadcast_block():
    pass
    

def _lower__ZL34nvshmemx_ulonglong_broadcast_blockiPyPKymi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmemx_ulonglong_broadcast_blockiPyPKymi_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_ulonglong_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL34nvshmemx_ulonglong_broadcast_blockiPyPKymi_nbst = declare_device(
        '_ZL34nvshmemx_ulonglong_broadcast_blockiPyPKymi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL34nvshmemx_ulonglong_broadcast_blockiPyPKymi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL34nvshmemx_ulonglong_broadcast_blockiPyPKymi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ulonglong_broadcast_block, int32, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmemx_ulonglong_broadcast_blockiPyPKymi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmemx_ulonglong_broadcast_blockiPyPKymi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL34nvshmemx_ulonglong_broadcast_blockiPyPKymi_nbst(shim_stream, shim_obj)


def int8_broadcast_block():
    pass
    

def _lower__ZL29nvshmemx_int8_broadcast_blockiPaPKami_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int8_broadcast_blockiPaPKami_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_int8_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL29nvshmemx_int8_broadcast_blockiPaPKami_nbst = declare_device(
        '_ZL29nvshmemx_int8_broadcast_blockiPaPKami_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL29nvshmemx_int8_broadcast_blockiPaPKami_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL29nvshmemx_int8_broadcast_blockiPaPKami_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int8_broadcast_block, int32, CPointer(int8), CPointer(int8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int8_broadcast_blockiPaPKami_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int8_broadcast_blockiPaPKami_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL29nvshmemx_int8_broadcast_blockiPaPKami_nbst(shim_stream, shim_obj)


def int16_broadcast_block():
    pass
    

def _lower__ZL30nvshmemx_int16_broadcast_blockiPsPKsmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int16_broadcast_blockiPsPKsmi_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_int16_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL30nvshmemx_int16_broadcast_blockiPsPKsmi_nbst = declare_device(
        '_ZL30nvshmemx_int16_broadcast_blockiPsPKsmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL30nvshmemx_int16_broadcast_blockiPsPKsmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL30nvshmemx_int16_broadcast_blockiPsPKsmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int16_broadcast_block, int32, CPointer(int16), CPointer(int16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int16_broadcast_blockiPsPKsmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int16_broadcast_blockiPsPKsmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL30nvshmemx_int16_broadcast_blockiPsPKsmi_nbst(shim_stream, shim_obj)


def int32_broadcast_block():
    pass
    

def _lower__ZL30nvshmemx_int32_broadcast_blockiPiPKimi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int32_broadcast_blockiPiPKimi_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_int32_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL30nvshmemx_int32_broadcast_blockiPiPKimi_nbst = declare_device(
        '_ZL30nvshmemx_int32_broadcast_blockiPiPKimi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL30nvshmemx_int32_broadcast_blockiPiPKimi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL30nvshmemx_int32_broadcast_blockiPiPKimi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int32_broadcast_block, int32, CPointer(int32), CPointer(int32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int32_broadcast_blockiPiPKimi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int32_broadcast_blockiPiPKimi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL30nvshmemx_int32_broadcast_blockiPiPKimi_nbst(shim_stream, shim_obj)


def int64_broadcast_block():
    pass
    

def _lower__ZL30nvshmemx_int64_broadcast_blockiPlPKlmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int64_broadcast_blockiPlPKlmi_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_int64_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL30nvshmemx_int64_broadcast_blockiPlPKlmi_nbst = declare_device(
        '_ZL30nvshmemx_int64_broadcast_blockiPlPKlmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL30nvshmemx_int64_broadcast_blockiPlPKlmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL30nvshmemx_int64_broadcast_blockiPlPKlmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(int64_broadcast_block, int32, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int64_broadcast_blockiPlPKlmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int64_broadcast_blockiPlPKlmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL30nvshmemx_int64_broadcast_blockiPlPKlmi_nbst(shim_stream, shim_obj)


def uint8_broadcast_block():
    pass
    

def _lower__ZL30nvshmemx_uint8_broadcast_blockiPhPKhmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint8_broadcast_blockiPhPKhmi_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_uint8_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL30nvshmemx_uint8_broadcast_blockiPhPKhmi_nbst = declare_device(
        '_ZL30nvshmemx_uint8_broadcast_blockiPhPKhmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL30nvshmemx_uint8_broadcast_blockiPhPKhmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL30nvshmemx_uint8_broadcast_blockiPhPKhmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint8_broadcast_block, int32, CPointer(uint8), CPointer(uint8), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint8_broadcast_blockiPhPKhmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint8_broadcast_blockiPhPKhmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint8_broadcast_blockiPhPKhmi_nbst(shim_stream, shim_obj)


def uint16_broadcast_block():
    pass
    

def _lower__ZL31nvshmemx_uint16_broadcast_blockiPtPKtmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint16_broadcast_blockiPtPKtmi_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_uint16_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL31nvshmemx_uint16_broadcast_blockiPtPKtmi_nbst = declare_device(
        '_ZL31nvshmemx_uint16_broadcast_blockiPtPKtmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL31nvshmemx_uint16_broadcast_blockiPtPKtmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL31nvshmemx_uint16_broadcast_blockiPtPKtmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint16_broadcast_block, int32, CPointer(uint16), CPointer(uint16), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint16_broadcast_blockiPtPKtmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint16_broadcast_blockiPtPKtmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint16_broadcast_blockiPtPKtmi_nbst(shim_stream, shim_obj)


def uint32_broadcast_block():
    pass
    

def _lower__ZL31nvshmemx_uint32_broadcast_blockiPjPKjmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint32_broadcast_blockiPjPKjmi_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_uint32_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL31nvshmemx_uint32_broadcast_blockiPjPKjmi_nbst = declare_device(
        '_ZL31nvshmemx_uint32_broadcast_blockiPjPKjmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL31nvshmemx_uint32_broadcast_blockiPjPKjmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL31nvshmemx_uint32_broadcast_blockiPjPKjmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint32_broadcast_block, int32, CPointer(uint32), CPointer(uint32), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint32_broadcast_blockiPjPKjmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint32_broadcast_blockiPjPKjmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint32_broadcast_blockiPjPKjmi_nbst(shim_stream, shim_obj)


def uint64_broadcast_block():
    pass
    

def _lower__ZL31nvshmemx_uint64_broadcast_blockiPmPKmmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint64_broadcast_blockiPmPKmmi_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_uint64_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL31nvshmemx_uint64_broadcast_blockiPmPKmmi_nbst = declare_device(
        '_ZL31nvshmemx_uint64_broadcast_blockiPmPKmmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL31nvshmemx_uint64_broadcast_blockiPmPKmmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL31nvshmemx_uint64_broadcast_blockiPmPKmmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(uint64_broadcast_block, int32, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint64_broadcast_blockiPmPKmmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint64_broadcast_blockiPmPKmmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint64_broadcast_blockiPmPKmmi_nbst(shim_stream, shim_obj)


def size_broadcast_block():
    pass
    

def _lower__ZL29nvshmemx_size_broadcast_blockiPmPKmmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_size_broadcast_blockiPmPKmmi_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_size_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL29nvshmemx_size_broadcast_blockiPmPKmmi_nbst = declare_device(
        '_ZL29nvshmemx_size_broadcast_blockiPmPKmmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL29nvshmemx_size_broadcast_blockiPmPKmmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL29nvshmemx_size_broadcast_blockiPmPKmmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(size_broadcast_block, int32, CPointer(uint64), CPointer(uint64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_size_broadcast_blockiPmPKmmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_size_broadcast_blockiPmPKmmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL29nvshmemx_size_broadcast_blockiPmPKmmi_nbst(shim_stream, shim_obj)


def ptrdiff_broadcast_block():
    pass
    

def _lower__ZL32nvshmemx_ptrdiff_broadcast_blockiPlPKlmi_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_ptrdiff_broadcast_blockiPlPKlmi_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nelems, int* PE_root) {
        retval = nvshmemx_ptrdiff_broadcast_block(*team, *dest, *source, *nelems, *PE_root);
        return 0;
    }
        """


    _ZL32nvshmemx_ptrdiff_broadcast_blockiPlPKlmi_nbst = declare_device(
        '_ZL32nvshmemx_ptrdiff_broadcast_blockiPlPKlmi_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)
        )
    )
    

    def _ZL32nvshmemx_ptrdiff_broadcast_blockiPlPKlmi_nbst_caller(arg_0, arg_1, arg_2, arg_3, arg_4):
        return _ZL32nvshmemx_ptrdiff_broadcast_blockiPlPKlmi_nbst(arg_0, arg_1, arg_2, arg_3, arg_4)
    

    @lower(ptrdiff_broadcast_block, int32, CPointer(int64), CPointer(int64), uint64, int32)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_ptrdiff_broadcast_blockiPlPKlmi_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_ptrdiff_broadcast_blockiPlPKlmi_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64), CPointer(int32)),
            ptrs,
        )



_lower__ZL32nvshmemx_ptrdiff_broadcast_blockiPlPKlmi_nbst(shim_stream, shim_obj)


def fcollectmem_warp():
    pass
    

def _lower__ZL25nvshmemx_fcollectmem_warpiPvPKvm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL25nvshmemx_fcollectmem_warpiPvPKvm_nbst(int &retval , int* team, void ** dest, void ** source, unsigned long* nelems) {
        retval = nvshmemx_fcollectmem_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL25nvshmemx_fcollectmem_warpiPvPKvm_nbst = declare_device(
        '_ZL25nvshmemx_fcollectmem_warpiPvPKvm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64)
        )
    )
    

    def _ZL25nvshmemx_fcollectmem_warpiPvPKvm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL25nvshmemx_fcollectmem_warpiPvPKvm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(fcollectmem_warp, int32, CPointer(void), CPointer(void), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL25nvshmemx_fcollectmem_warpiPvPKvm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL25nvshmemx_fcollectmem_warpiPvPKvm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL25nvshmemx_fcollectmem_warpiPvPKvm_nbst(shim_stream, shim_obj)


def fcollectmem_block():
    pass
    

def _lower__ZL26nvshmemx_fcollectmem_blockiPvPKvm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL26nvshmemx_fcollectmem_blockiPvPKvm_nbst(int &retval , int* team, void ** dest, void ** source, unsigned long* nelems) {
        retval = nvshmemx_fcollectmem_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL26nvshmemx_fcollectmem_blockiPvPKvm_nbst = declare_device(
        '_ZL26nvshmemx_fcollectmem_blockiPvPKvm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64)
        )
    )
    

    def _ZL26nvshmemx_fcollectmem_blockiPvPKvm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL26nvshmemx_fcollectmem_blockiPvPKvm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(fcollectmem_block, int32, CPointer(void), CPointer(void), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL26nvshmemx_fcollectmem_blockiPvPKvm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL26nvshmemx_fcollectmem_blockiPvPKvm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(void)), CPointer(CPointer(void)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL26nvshmemx_fcollectmem_blockiPvPKvm_nbst(shim_stream, shim_obj)


def bfloat16_fcollect_warp():
    pass
    

def _lower__ZL31nvshmemx_bfloat16_fcollect_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_bfloat16_fcollect_warpiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems) {
        retval = nvshmemx_bfloat16_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL31nvshmemx_bfloat16_fcollect_warpiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL31nvshmemx_bfloat16_fcollect_warpiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_bfloat16_fcollect_warpiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_bfloat16_fcollect_warpiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_fcollect_warp, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_bfloat16_fcollect_warpiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_bfloat16_fcollect_warpiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_bfloat16_fcollect_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_fcollect_warp():
    pass
    

def _lower__ZL27nvshmemx_half_fcollect_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmemx_half_fcollect_warpiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nelems) {
        retval = nvshmemx_half_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL27nvshmemx_half_fcollect_warpiP6__halfPKS_m_nbst = declare_device(
        '_ZL27nvshmemx_half_fcollect_warpiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmemx_half_fcollect_warpiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmemx_half_fcollect_warpiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_fcollect_warp, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmemx_half_fcollect_warpiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmemx_half_fcollect_warpiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmemx_half_fcollect_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_fcollect_warp():
    pass
    

def _lower__ZL28nvshmemx_float_fcollect_warpiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_float_fcollect_warpiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nelems) {
        retval = nvshmemx_float_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_float_fcollect_warpiPfPKfm_nbst = declare_device(
        '_ZL28nvshmemx_float_fcollect_warpiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_float_fcollect_warpiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_float_fcollect_warpiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_fcollect_warp, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_float_fcollect_warpiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_float_fcollect_warpiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_float_fcollect_warpiPfPKfm_nbst(shim_stream, shim_obj)


def double_fcollect_warp():
    pass
    

def _lower__ZL29nvshmemx_double_fcollect_warpiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_double_fcollect_warpiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nelems) {
        retval = nvshmemx_double_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_double_fcollect_warpiPdPKdm_nbst = declare_device(
        '_ZL29nvshmemx_double_fcollect_warpiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_double_fcollect_warpiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_double_fcollect_warpiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_fcollect_warp, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_double_fcollect_warpiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_double_fcollect_warpiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_double_fcollect_warpiPdPKdm_nbst(shim_stream, shim_obj)


def char_fcollect_warp():
    pass
    

def _lower__ZL27nvshmemx_char_fcollect_warpiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmemx_char_fcollect_warpiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nelems) {
        retval = nvshmemx_char_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL27nvshmemx_char_fcollect_warpiPcPKcm_nbst = declare_device(
        '_ZL27nvshmemx_char_fcollect_warpiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmemx_char_fcollect_warpiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmemx_char_fcollect_warpiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_fcollect_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmemx_char_fcollect_warpiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmemx_char_fcollect_warpiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmemx_char_fcollect_warpiPcPKcm_nbst(shim_stream, shim_obj)


def short_fcollect_warp():
    pass
    

def _lower__ZL28nvshmemx_short_fcollect_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_short_fcollect_warpiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nelems) {
        retval = nvshmemx_short_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_short_fcollect_warpiPsPKsm_nbst = declare_device(
        '_ZL28nvshmemx_short_fcollect_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_short_fcollect_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_short_fcollect_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_fcollect_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_short_fcollect_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_short_fcollect_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_short_fcollect_warpiPsPKsm_nbst(shim_stream, shim_obj)


def schar_fcollect_warp():
    pass
    

def _lower__ZL28nvshmemx_schar_fcollect_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_schar_fcollect_warpiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nelems) {
        retval = nvshmemx_schar_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_schar_fcollect_warpiPaPKam_nbst = declare_device(
        '_ZL28nvshmemx_schar_fcollect_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_schar_fcollect_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_schar_fcollect_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_fcollect_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_schar_fcollect_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_schar_fcollect_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_schar_fcollect_warpiPaPKam_nbst(shim_stream, shim_obj)


def int_fcollect_warp():
    pass
    

def _lower__ZL26nvshmemx_int_fcollect_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL26nvshmemx_int_fcollect_warpiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nelems) {
        retval = nvshmemx_int_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL26nvshmemx_int_fcollect_warpiPiPKim_nbst = declare_device(
        '_ZL26nvshmemx_int_fcollect_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL26nvshmemx_int_fcollect_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL26nvshmemx_int_fcollect_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_fcollect_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL26nvshmemx_int_fcollect_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL26nvshmemx_int_fcollect_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL26nvshmemx_int_fcollect_warpiPiPKim_nbst(shim_stream, shim_obj)


def long_fcollect_warp():
    pass
    

def _lower__ZL27nvshmemx_long_fcollect_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmemx_long_fcollect_warpiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nelems) {
        retval = nvshmemx_long_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL27nvshmemx_long_fcollect_warpiPlPKlm_nbst = declare_device(
        '_ZL27nvshmemx_long_fcollect_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmemx_long_fcollect_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmemx_long_fcollect_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_fcollect_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmemx_long_fcollect_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmemx_long_fcollect_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmemx_long_fcollect_warpiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_fcollect_warp():
    pass
    

def _lower__ZL31nvshmemx_longlong_fcollect_warpiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_longlong_fcollect_warpiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nelems) {
        retval = nvshmemx_longlong_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL31nvshmemx_longlong_fcollect_warpiPxPKxm_nbst = declare_device(
        '_ZL31nvshmemx_longlong_fcollect_warpiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_longlong_fcollect_warpiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_longlong_fcollect_warpiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_fcollect_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_longlong_fcollect_warpiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_longlong_fcollect_warpiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_longlong_fcollect_warpiPxPKxm_nbst(shim_stream, shim_obj)


def uchar_fcollect_warp():
    pass
    

def _lower__ZL28nvshmemx_uchar_fcollect_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_uchar_fcollect_warpiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nelems) {
        retval = nvshmemx_uchar_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_uchar_fcollect_warpiPhPKhm_nbst = declare_device(
        '_ZL28nvshmemx_uchar_fcollect_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_uchar_fcollect_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_uchar_fcollect_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_fcollect_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_uchar_fcollect_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_uchar_fcollect_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_uchar_fcollect_warpiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_fcollect_warp():
    pass
    

def _lower__ZL29nvshmemx_ushort_fcollect_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_ushort_fcollect_warpiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nelems) {
        retval = nvshmemx_ushort_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_ushort_fcollect_warpiPtPKtm_nbst = declare_device(
        '_ZL29nvshmemx_ushort_fcollect_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_ushort_fcollect_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_ushort_fcollect_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_fcollect_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_ushort_fcollect_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_ushort_fcollect_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_ushort_fcollect_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint_fcollect_warp():
    pass
    

def _lower__ZL27nvshmemx_uint_fcollect_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmemx_uint_fcollect_warpiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nelems) {
        retval = nvshmemx_uint_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL27nvshmemx_uint_fcollect_warpiPjPKjm_nbst = declare_device(
        '_ZL27nvshmemx_uint_fcollect_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmemx_uint_fcollect_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmemx_uint_fcollect_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_fcollect_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmemx_uint_fcollect_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmemx_uint_fcollect_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmemx_uint_fcollect_warpiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_fcollect_warp():
    pass
    

def _lower__ZL28nvshmemx_ulong_fcollect_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_ulong_fcollect_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nelems) {
        retval = nvshmemx_ulong_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_ulong_fcollect_warpiPmPKmm_nbst = declare_device(
        '_ZL28nvshmemx_ulong_fcollect_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_ulong_fcollect_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_ulong_fcollect_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_fcollect_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_ulong_fcollect_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_ulong_fcollect_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_ulong_fcollect_warpiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_fcollect_warp():
    pass
    

def _lower__ZL32nvshmemx_ulonglong_fcollect_warpiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_ulonglong_fcollect_warpiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems) {
        retval = nvshmemx_ulonglong_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL32nvshmemx_ulonglong_fcollect_warpiPyPKym_nbst = declare_device(
        '_ZL32nvshmemx_ulonglong_fcollect_warpiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_ulonglong_fcollect_warpiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_ulonglong_fcollect_warpiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_fcollect_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_ulonglong_fcollect_warpiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_ulonglong_fcollect_warpiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_ulonglong_fcollect_warpiPyPKym_nbst(shim_stream, shim_obj)


def int8_fcollect_warp():
    pass
    

def _lower__ZL27nvshmemx_int8_fcollect_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmemx_int8_fcollect_warpiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nelems) {
        retval = nvshmemx_int8_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL27nvshmemx_int8_fcollect_warpiPaPKam_nbst = declare_device(
        '_ZL27nvshmemx_int8_fcollect_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmemx_int8_fcollect_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmemx_int8_fcollect_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_fcollect_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmemx_int8_fcollect_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmemx_int8_fcollect_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmemx_int8_fcollect_warpiPaPKam_nbst(shim_stream, shim_obj)


def int16_fcollect_warp():
    pass
    

def _lower__ZL28nvshmemx_int16_fcollect_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_int16_fcollect_warpiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nelems) {
        retval = nvshmemx_int16_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_int16_fcollect_warpiPsPKsm_nbst = declare_device(
        '_ZL28nvshmemx_int16_fcollect_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_int16_fcollect_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_int16_fcollect_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_fcollect_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_int16_fcollect_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_int16_fcollect_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_int16_fcollect_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int32_fcollect_warp():
    pass
    

def _lower__ZL28nvshmemx_int32_fcollect_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_int32_fcollect_warpiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nelems) {
        retval = nvshmemx_int32_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_int32_fcollect_warpiPiPKim_nbst = declare_device(
        '_ZL28nvshmemx_int32_fcollect_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_int32_fcollect_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_int32_fcollect_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_fcollect_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_int32_fcollect_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_int32_fcollect_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_int32_fcollect_warpiPiPKim_nbst(shim_stream, shim_obj)


def int64_fcollect_warp():
    pass
    

def _lower__ZL28nvshmemx_int64_fcollect_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_int64_fcollect_warpiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nelems) {
        retval = nvshmemx_int64_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_int64_fcollect_warpiPlPKlm_nbst = declare_device(
        '_ZL28nvshmemx_int64_fcollect_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_int64_fcollect_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_int64_fcollect_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_fcollect_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_int64_fcollect_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_int64_fcollect_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_int64_fcollect_warpiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_fcollect_warp():
    pass
    

def _lower__ZL28nvshmemx_uint8_fcollect_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_uint8_fcollect_warpiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nelems) {
        retval = nvshmemx_uint8_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_uint8_fcollect_warpiPhPKhm_nbst = declare_device(
        '_ZL28nvshmemx_uint8_fcollect_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_uint8_fcollect_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_uint8_fcollect_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_fcollect_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_uint8_fcollect_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_uint8_fcollect_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_uint8_fcollect_warpiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_fcollect_warp():
    pass
    

def _lower__ZL29nvshmemx_uint16_fcollect_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uint16_fcollect_warpiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nelems) {
        retval = nvshmemx_uint16_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_uint16_fcollect_warpiPtPKtm_nbst = declare_device(
        '_ZL29nvshmemx_uint16_fcollect_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_uint16_fcollect_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_uint16_fcollect_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_fcollect_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uint16_fcollect_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uint16_fcollect_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_uint16_fcollect_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_fcollect_warp():
    pass
    

def _lower__ZL29nvshmemx_uint32_fcollect_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uint32_fcollect_warpiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nelems) {
        retval = nvshmemx_uint32_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_uint32_fcollect_warpiPjPKjm_nbst = declare_device(
        '_ZL29nvshmemx_uint32_fcollect_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_uint32_fcollect_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_uint32_fcollect_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_fcollect_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uint32_fcollect_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uint32_fcollect_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_uint32_fcollect_warpiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_fcollect_warp():
    pass
    

def _lower__ZL29nvshmemx_uint64_fcollect_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uint64_fcollect_warpiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nelems) {
        retval = nvshmemx_uint64_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_uint64_fcollect_warpiPmPKmm_nbst = declare_device(
        '_ZL29nvshmemx_uint64_fcollect_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_uint64_fcollect_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_uint64_fcollect_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_fcollect_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uint64_fcollect_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uint64_fcollect_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_uint64_fcollect_warpiPmPKmm_nbst(shim_stream, shim_obj)


def size_fcollect_warp():
    pass
    

def _lower__ZL27nvshmemx_size_fcollect_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmemx_size_fcollect_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nelems) {
        retval = nvshmemx_size_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL27nvshmemx_size_fcollect_warpiPmPKmm_nbst = declare_device(
        '_ZL27nvshmemx_size_fcollect_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmemx_size_fcollect_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmemx_size_fcollect_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_fcollect_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmemx_size_fcollect_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmemx_size_fcollect_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmemx_size_fcollect_warpiPmPKmm_nbst(shim_stream, shim_obj)


def ptrdiff_fcollect_warp():
    pass
    

def _lower__ZL30nvshmemx_ptrdiff_fcollect_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_ptrdiff_fcollect_warpiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nelems) {
        retval = nvshmemx_ptrdiff_fcollect_warp(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL30nvshmemx_ptrdiff_fcollect_warpiPlPKlm_nbst = declare_device(
        '_ZL30nvshmemx_ptrdiff_fcollect_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_ptrdiff_fcollect_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_ptrdiff_fcollect_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ptrdiff_fcollect_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_ptrdiff_fcollect_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_ptrdiff_fcollect_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_ptrdiff_fcollect_warpiPlPKlm_nbst(shim_stream, shim_obj)


def bfloat16_fcollect_block():
    pass
    

def _lower__ZL32nvshmemx_bfloat16_fcollect_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_bfloat16_fcollect_blockiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nelems) {
        retval = nvshmemx_bfloat16_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL32nvshmemx_bfloat16_fcollect_blockiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL32nvshmemx_bfloat16_fcollect_blockiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_bfloat16_fcollect_blockiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_bfloat16_fcollect_blockiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_fcollect_block, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_bfloat16_fcollect_blockiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_bfloat16_fcollect_blockiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_bfloat16_fcollect_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_fcollect_block():
    pass
    

def _lower__ZL28nvshmemx_half_fcollect_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_half_fcollect_blockiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nelems) {
        retval = nvshmemx_half_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_half_fcollect_blockiP6__halfPKS_m_nbst = declare_device(
        '_ZL28nvshmemx_half_fcollect_blockiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_half_fcollect_blockiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_half_fcollect_blockiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_fcollect_block, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_half_fcollect_blockiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_half_fcollect_blockiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_half_fcollect_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_fcollect_block():
    pass
    

def _lower__ZL29nvshmemx_float_fcollect_blockiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_float_fcollect_blockiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nelems) {
        retval = nvshmemx_float_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_float_fcollect_blockiPfPKfm_nbst = declare_device(
        '_ZL29nvshmemx_float_fcollect_blockiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_float_fcollect_blockiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_float_fcollect_blockiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_fcollect_block, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_float_fcollect_blockiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_float_fcollect_blockiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_float_fcollect_blockiPfPKfm_nbst(shim_stream, shim_obj)


def double_fcollect_block():
    pass
    

def _lower__ZL30nvshmemx_double_fcollect_blockiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_double_fcollect_blockiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nelems) {
        retval = nvshmemx_double_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL30nvshmemx_double_fcollect_blockiPdPKdm_nbst = declare_device(
        '_ZL30nvshmemx_double_fcollect_blockiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_double_fcollect_blockiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_double_fcollect_blockiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_fcollect_block, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_double_fcollect_blockiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_double_fcollect_blockiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_double_fcollect_blockiPdPKdm_nbst(shim_stream, shim_obj)


def char_fcollect_block():
    pass
    

def _lower__ZL28nvshmemx_char_fcollect_blockiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_char_fcollect_blockiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nelems) {
        retval = nvshmemx_char_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_char_fcollect_blockiPcPKcm_nbst = declare_device(
        '_ZL28nvshmemx_char_fcollect_blockiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_char_fcollect_blockiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_char_fcollect_blockiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_fcollect_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_char_fcollect_blockiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_char_fcollect_blockiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_char_fcollect_blockiPcPKcm_nbst(shim_stream, shim_obj)


def short_fcollect_block():
    pass
    

def _lower__ZL29nvshmemx_short_fcollect_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_short_fcollect_blockiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nelems) {
        retval = nvshmemx_short_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_short_fcollect_blockiPsPKsm_nbst = declare_device(
        '_ZL29nvshmemx_short_fcollect_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_short_fcollect_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_short_fcollect_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_fcollect_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_short_fcollect_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_short_fcollect_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_short_fcollect_blockiPsPKsm_nbst(shim_stream, shim_obj)


def schar_fcollect_block():
    pass
    

def _lower__ZL29nvshmemx_schar_fcollect_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_schar_fcollect_blockiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nelems) {
        retval = nvshmemx_schar_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_schar_fcollect_blockiPaPKam_nbst = declare_device(
        '_ZL29nvshmemx_schar_fcollect_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_schar_fcollect_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_schar_fcollect_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_fcollect_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_schar_fcollect_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_schar_fcollect_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_schar_fcollect_blockiPaPKam_nbst(shim_stream, shim_obj)


def int_fcollect_block():
    pass
    

def _lower__ZL27nvshmemx_int_fcollect_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL27nvshmemx_int_fcollect_blockiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nelems) {
        retval = nvshmemx_int_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL27nvshmemx_int_fcollect_blockiPiPKim_nbst = declare_device(
        '_ZL27nvshmemx_int_fcollect_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL27nvshmemx_int_fcollect_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL27nvshmemx_int_fcollect_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_fcollect_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL27nvshmemx_int_fcollect_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL27nvshmemx_int_fcollect_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL27nvshmemx_int_fcollect_blockiPiPKim_nbst(shim_stream, shim_obj)


def long_fcollect_block():
    pass
    

def _lower__ZL28nvshmemx_long_fcollect_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_long_fcollect_blockiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nelems) {
        retval = nvshmemx_long_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_long_fcollect_blockiPlPKlm_nbst = declare_device(
        '_ZL28nvshmemx_long_fcollect_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_long_fcollect_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_long_fcollect_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_fcollect_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_long_fcollect_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_long_fcollect_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_long_fcollect_blockiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_fcollect_block():
    pass
    

def _lower__ZL32nvshmemx_longlong_fcollect_blockiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_longlong_fcollect_blockiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nelems) {
        retval = nvshmemx_longlong_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL32nvshmemx_longlong_fcollect_blockiPxPKxm_nbst = declare_device(
        '_ZL32nvshmemx_longlong_fcollect_blockiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_longlong_fcollect_blockiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_longlong_fcollect_blockiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_fcollect_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_longlong_fcollect_blockiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_longlong_fcollect_blockiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_longlong_fcollect_blockiPxPKxm_nbst(shim_stream, shim_obj)


def uchar_fcollect_block():
    pass
    

def _lower__ZL29nvshmemx_uchar_fcollect_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uchar_fcollect_blockiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nelems) {
        retval = nvshmemx_uchar_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_uchar_fcollect_blockiPhPKhm_nbst = declare_device(
        '_ZL29nvshmemx_uchar_fcollect_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_uchar_fcollect_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_uchar_fcollect_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_fcollect_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uchar_fcollect_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uchar_fcollect_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_uchar_fcollect_blockiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_fcollect_block():
    pass
    

def _lower__ZL30nvshmemx_ushort_fcollect_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_ushort_fcollect_blockiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nelems) {
        retval = nvshmemx_ushort_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL30nvshmemx_ushort_fcollect_blockiPtPKtm_nbst = declare_device(
        '_ZL30nvshmemx_ushort_fcollect_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_ushort_fcollect_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_ushort_fcollect_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_fcollect_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_ushort_fcollect_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_ushort_fcollect_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_ushort_fcollect_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint_fcollect_block():
    pass
    

def _lower__ZL28nvshmemx_uint_fcollect_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_uint_fcollect_blockiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nelems) {
        retval = nvshmemx_uint_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_uint_fcollect_blockiPjPKjm_nbst = declare_device(
        '_ZL28nvshmemx_uint_fcollect_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_uint_fcollect_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_uint_fcollect_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_fcollect_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_uint_fcollect_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_uint_fcollect_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_uint_fcollect_blockiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_fcollect_block():
    pass
    

def _lower__ZL29nvshmemx_ulong_fcollect_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_ulong_fcollect_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nelems) {
        retval = nvshmemx_ulong_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_ulong_fcollect_blockiPmPKmm_nbst = declare_device(
        '_ZL29nvshmemx_ulong_fcollect_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_ulong_fcollect_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_ulong_fcollect_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_fcollect_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_ulong_fcollect_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_ulong_fcollect_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_ulong_fcollect_blockiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_fcollect_block():
    pass
    

def _lower__ZL33nvshmemx_ulonglong_fcollect_blockiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmemx_ulonglong_fcollect_blockiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nelems) {
        retval = nvshmemx_ulonglong_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL33nvshmemx_ulonglong_fcollect_blockiPyPKym_nbst = declare_device(
        '_ZL33nvshmemx_ulonglong_fcollect_blockiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL33nvshmemx_ulonglong_fcollect_blockiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL33nvshmemx_ulonglong_fcollect_blockiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_fcollect_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmemx_ulonglong_fcollect_blockiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmemx_ulonglong_fcollect_blockiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL33nvshmemx_ulonglong_fcollect_blockiPyPKym_nbst(shim_stream, shim_obj)


def int8_fcollect_block():
    pass
    

def _lower__ZL28nvshmemx_int8_fcollect_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_int8_fcollect_blockiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nelems) {
        retval = nvshmemx_int8_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_int8_fcollect_blockiPaPKam_nbst = declare_device(
        '_ZL28nvshmemx_int8_fcollect_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_int8_fcollect_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_int8_fcollect_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_fcollect_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_int8_fcollect_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_int8_fcollect_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_int8_fcollect_blockiPaPKam_nbst(shim_stream, shim_obj)


def int16_fcollect_block():
    pass
    

def _lower__ZL29nvshmemx_int16_fcollect_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int16_fcollect_blockiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nelems) {
        retval = nvshmemx_int16_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_int16_fcollect_blockiPsPKsm_nbst = declare_device(
        '_ZL29nvshmemx_int16_fcollect_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_int16_fcollect_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_int16_fcollect_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_fcollect_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int16_fcollect_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int16_fcollect_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_int16_fcollect_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int32_fcollect_block():
    pass
    

def _lower__ZL29nvshmemx_int32_fcollect_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int32_fcollect_blockiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nelems) {
        retval = nvshmemx_int32_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_int32_fcollect_blockiPiPKim_nbst = declare_device(
        '_ZL29nvshmemx_int32_fcollect_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_int32_fcollect_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_int32_fcollect_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_fcollect_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int32_fcollect_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int32_fcollect_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_int32_fcollect_blockiPiPKim_nbst(shim_stream, shim_obj)


def int64_fcollect_block():
    pass
    

def _lower__ZL29nvshmemx_int64_fcollect_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int64_fcollect_blockiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nelems) {
        retval = nvshmemx_int64_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_int64_fcollect_blockiPlPKlm_nbst = declare_device(
        '_ZL29nvshmemx_int64_fcollect_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_int64_fcollect_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_int64_fcollect_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_fcollect_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int64_fcollect_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int64_fcollect_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_int64_fcollect_blockiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_fcollect_block():
    pass
    

def _lower__ZL29nvshmemx_uint8_fcollect_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uint8_fcollect_blockiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nelems) {
        retval = nvshmemx_uint8_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL29nvshmemx_uint8_fcollect_blockiPhPKhm_nbst = declare_device(
        '_ZL29nvshmemx_uint8_fcollect_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_uint8_fcollect_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_uint8_fcollect_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_fcollect_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uint8_fcollect_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uint8_fcollect_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_uint8_fcollect_blockiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_fcollect_block():
    pass
    

def _lower__ZL30nvshmemx_uint16_fcollect_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint16_fcollect_blockiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nelems) {
        retval = nvshmemx_uint16_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL30nvshmemx_uint16_fcollect_blockiPtPKtm_nbst = declare_device(
        '_ZL30nvshmemx_uint16_fcollect_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint16_fcollect_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint16_fcollect_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_fcollect_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint16_fcollect_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint16_fcollect_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint16_fcollect_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_fcollect_block():
    pass
    

def _lower__ZL30nvshmemx_uint32_fcollect_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint32_fcollect_blockiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nelems) {
        retval = nvshmemx_uint32_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL30nvshmemx_uint32_fcollect_blockiPjPKjm_nbst = declare_device(
        '_ZL30nvshmemx_uint32_fcollect_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint32_fcollect_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint32_fcollect_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_fcollect_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint32_fcollect_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint32_fcollect_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint32_fcollect_blockiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_fcollect_block():
    pass
    

def _lower__ZL30nvshmemx_uint64_fcollect_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint64_fcollect_blockiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nelems) {
        retval = nvshmemx_uint64_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL30nvshmemx_uint64_fcollect_blockiPmPKmm_nbst = declare_device(
        '_ZL30nvshmemx_uint64_fcollect_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint64_fcollect_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint64_fcollect_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_fcollect_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint64_fcollect_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint64_fcollect_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint64_fcollect_blockiPmPKmm_nbst(shim_stream, shim_obj)


def size_fcollect_block():
    pass
    

def _lower__ZL28nvshmemx_size_fcollect_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_size_fcollect_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nelems) {
        retval = nvshmemx_size_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL28nvshmemx_size_fcollect_blockiPmPKmm_nbst = declare_device(
        '_ZL28nvshmemx_size_fcollect_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_size_fcollect_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_size_fcollect_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_fcollect_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_size_fcollect_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_size_fcollect_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_size_fcollect_blockiPmPKmm_nbst(shim_stream, shim_obj)


def ptrdiff_fcollect_block():
    pass
    

def _lower__ZL31nvshmemx_ptrdiff_fcollect_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_ptrdiff_fcollect_blockiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nelems) {
        retval = nvshmemx_ptrdiff_fcollect_block(*team, *dest, *source, *nelems);
        return 0;
    }
        """


    _ZL31nvshmemx_ptrdiff_fcollect_blockiPlPKlm_nbst = declare_device(
        '_ZL31nvshmemx_ptrdiff_fcollect_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_ptrdiff_fcollect_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_ptrdiff_fcollect_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ptrdiff_fcollect_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_ptrdiff_fcollect_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_ptrdiff_fcollect_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_ptrdiff_fcollect_blockiPlPKlm_nbst(shim_stream, shim_obj)


def uchar_and_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_uchar_and_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uchar_and_reduce_warpiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_and_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uchar_and_reduce_warpiPhPKhm_nbst = declare_device(
        '_ZL30nvshmemx_uchar_and_reduce_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uchar_and_reduce_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uchar_and_reduce_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_and_reduce_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uchar_and_reduce_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uchar_and_reduce_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uchar_and_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_and_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_ushort_and_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_ushort_and_reduce_warpiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_and_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_ushort_and_reduce_warpiPtPKtm_nbst = declare_device(
        '_ZL31nvshmemx_ushort_and_reduce_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_ushort_and_reduce_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_ushort_and_reduce_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_and_reduce_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_ushort_and_reduce_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_ushort_and_reduce_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_ushort_and_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint_and_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_uint_and_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uint_and_reduce_warpiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_and_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_uint_and_reduce_warpiPjPKjm_nbst = declare_device(
        '_ZL29nvshmemx_uint_and_reduce_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_uint_and_reduce_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_uint_and_reduce_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_and_reduce_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uint_and_reduce_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uint_and_reduce_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_uint_and_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_and_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_ulong_and_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_ulong_and_reduce_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_and_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_ulong_and_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL30nvshmemx_ulong_and_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_ulong_and_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_ulong_and_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_and_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_ulong_and_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_ulong_and_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_ulong_and_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_and_reduce_warp():
    pass
    

def _lower__ZL34nvshmemx_ulonglong_and_reduce_warpiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmemx_ulonglong_and_reduce_warpiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_and_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmemx_ulonglong_and_reduce_warpiPyPKym_nbst = declare_device(
        '_ZL34nvshmemx_ulonglong_and_reduce_warpiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmemx_ulonglong_and_reduce_warpiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmemx_ulonglong_and_reduce_warpiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_and_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmemx_ulonglong_and_reduce_warpiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmemx_ulonglong_and_reduce_warpiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmemx_ulonglong_and_reduce_warpiPyPKym_nbst(shim_stream, shim_obj)


def int8_and_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_int8_and_reduce_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int8_and_reduce_warpiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_and_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_int8_and_reduce_warpiPaPKam_nbst = declare_device(
        '_ZL29nvshmemx_int8_and_reduce_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_int8_and_reduce_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_int8_and_reduce_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_and_reduce_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int8_and_reduce_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int8_and_reduce_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_int8_and_reduce_warpiPaPKam_nbst(shim_stream, shim_obj)


def int16_and_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_int16_and_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int16_and_reduce_warpiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_and_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int16_and_reduce_warpiPsPKsm_nbst = declare_device(
        '_ZL30nvshmemx_int16_and_reduce_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int16_and_reduce_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int16_and_reduce_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_and_reduce_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int16_and_reduce_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int16_and_reduce_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int16_and_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int32_and_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_int32_and_reduce_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int32_and_reduce_warpiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_and_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int32_and_reduce_warpiPiPKim_nbst = declare_device(
        '_ZL30nvshmemx_int32_and_reduce_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int32_and_reduce_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int32_and_reduce_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_and_reduce_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int32_and_reduce_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int32_and_reduce_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int32_and_reduce_warpiPiPKim_nbst(shim_stream, shim_obj)


def int64_and_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_int64_and_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int64_and_reduce_warpiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_and_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int64_and_reduce_warpiPlPKlm_nbst = declare_device(
        '_ZL30nvshmemx_int64_and_reduce_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int64_and_reduce_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int64_and_reduce_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_and_reduce_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int64_and_reduce_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int64_and_reduce_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int64_and_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_and_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_uint8_and_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint8_and_reduce_warpiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_and_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uint8_and_reduce_warpiPhPKhm_nbst = declare_device(
        '_ZL30nvshmemx_uint8_and_reduce_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint8_and_reduce_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint8_and_reduce_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_and_reduce_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint8_and_reduce_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint8_and_reduce_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint8_and_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_and_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_uint16_and_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint16_and_reduce_warpiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_and_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint16_and_reduce_warpiPtPKtm_nbst = declare_device(
        '_ZL31nvshmemx_uint16_and_reduce_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint16_and_reduce_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint16_and_reduce_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_and_reduce_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint16_and_reduce_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint16_and_reduce_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint16_and_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_and_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_uint32_and_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint32_and_reduce_warpiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_and_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint32_and_reduce_warpiPjPKjm_nbst = declare_device(
        '_ZL31nvshmemx_uint32_and_reduce_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint32_and_reduce_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint32_and_reduce_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_and_reduce_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint32_and_reduce_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint32_and_reduce_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint32_and_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_and_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_uint64_and_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint64_and_reduce_warpiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_and_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint64_and_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL31nvshmemx_uint64_and_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint64_and_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint64_and_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_and_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint64_and_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint64_and_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint64_and_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def size_and_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_size_and_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_size_and_reduce_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_and_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_size_and_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL29nvshmemx_size_and_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_size_and_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_size_and_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_and_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_size_and_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_size_and_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_size_and_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def uchar_or_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_uchar_or_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uchar_or_reduce_warpiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_or_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_uchar_or_reduce_warpiPhPKhm_nbst = declare_device(
        '_ZL29nvshmemx_uchar_or_reduce_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_uchar_or_reduce_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_uchar_or_reduce_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_or_reduce_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uchar_or_reduce_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uchar_or_reduce_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_uchar_or_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_or_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_ushort_or_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_ushort_or_reduce_warpiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_or_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_ushort_or_reduce_warpiPtPKtm_nbst = declare_device(
        '_ZL30nvshmemx_ushort_or_reduce_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_ushort_or_reduce_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_ushort_or_reduce_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_or_reduce_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_ushort_or_reduce_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_ushort_or_reduce_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_ushort_or_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint_or_reduce_warp():
    pass
    

def _lower__ZL28nvshmemx_uint_or_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_uint_or_reduce_warpiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_or_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL28nvshmemx_uint_or_reduce_warpiPjPKjm_nbst = declare_device(
        '_ZL28nvshmemx_uint_or_reduce_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_uint_or_reduce_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_uint_or_reduce_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_or_reduce_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_uint_or_reduce_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_uint_or_reduce_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_uint_or_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_or_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_ulong_or_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_ulong_or_reduce_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_or_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_ulong_or_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL29nvshmemx_ulong_or_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_ulong_or_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_ulong_or_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_or_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_ulong_or_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_ulong_or_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_ulong_or_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_or_reduce_warp():
    pass
    

def _lower__ZL33nvshmemx_ulonglong_or_reduce_warpiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmemx_ulonglong_or_reduce_warpiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_or_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL33nvshmemx_ulonglong_or_reduce_warpiPyPKym_nbst = declare_device(
        '_ZL33nvshmemx_ulonglong_or_reduce_warpiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL33nvshmemx_ulonglong_or_reduce_warpiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL33nvshmemx_ulonglong_or_reduce_warpiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_or_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmemx_ulonglong_or_reduce_warpiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmemx_ulonglong_or_reduce_warpiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL33nvshmemx_ulonglong_or_reduce_warpiPyPKym_nbst(shim_stream, shim_obj)


def int8_or_reduce_warp():
    pass
    

def _lower__ZL28nvshmemx_int8_or_reduce_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_int8_or_reduce_warpiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_or_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL28nvshmemx_int8_or_reduce_warpiPaPKam_nbst = declare_device(
        '_ZL28nvshmemx_int8_or_reduce_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_int8_or_reduce_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_int8_or_reduce_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_or_reduce_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_int8_or_reduce_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_int8_or_reduce_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_int8_or_reduce_warpiPaPKam_nbst(shim_stream, shim_obj)


def int16_or_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_int16_or_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int16_or_reduce_warpiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_or_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_int16_or_reduce_warpiPsPKsm_nbst = declare_device(
        '_ZL29nvshmemx_int16_or_reduce_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_int16_or_reduce_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_int16_or_reduce_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_or_reduce_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int16_or_reduce_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int16_or_reduce_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_int16_or_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int32_or_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_int32_or_reduce_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int32_or_reduce_warpiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_or_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_int32_or_reduce_warpiPiPKim_nbst = declare_device(
        '_ZL29nvshmemx_int32_or_reduce_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_int32_or_reduce_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_int32_or_reduce_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_or_reduce_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int32_or_reduce_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int32_or_reduce_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_int32_or_reduce_warpiPiPKim_nbst(shim_stream, shim_obj)


def int64_or_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_int64_or_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int64_or_reduce_warpiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_or_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_int64_or_reduce_warpiPlPKlm_nbst = declare_device(
        '_ZL29nvshmemx_int64_or_reduce_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_int64_or_reduce_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_int64_or_reduce_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_or_reduce_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int64_or_reduce_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int64_or_reduce_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_int64_or_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_or_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_uint8_or_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uint8_or_reduce_warpiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_or_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_uint8_or_reduce_warpiPhPKhm_nbst = declare_device(
        '_ZL29nvshmemx_uint8_or_reduce_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_uint8_or_reduce_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_uint8_or_reduce_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_or_reduce_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uint8_or_reduce_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uint8_or_reduce_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_uint8_or_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_or_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_uint16_or_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint16_or_reduce_warpiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_or_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uint16_or_reduce_warpiPtPKtm_nbst = declare_device(
        '_ZL30nvshmemx_uint16_or_reduce_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint16_or_reduce_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint16_or_reduce_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_or_reduce_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint16_or_reduce_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint16_or_reduce_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint16_or_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_or_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_uint32_or_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint32_or_reduce_warpiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_or_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uint32_or_reduce_warpiPjPKjm_nbst = declare_device(
        '_ZL30nvshmemx_uint32_or_reduce_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint32_or_reduce_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint32_or_reduce_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_or_reduce_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint32_or_reduce_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint32_or_reduce_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint32_or_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_or_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_uint64_or_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint64_or_reduce_warpiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_or_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uint64_or_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL30nvshmemx_uint64_or_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint64_or_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint64_or_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_or_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint64_or_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint64_or_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint64_or_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def size_or_reduce_warp():
    pass
    

def _lower__ZL28nvshmemx_size_or_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_size_or_reduce_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_or_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL28nvshmemx_size_or_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL28nvshmemx_size_or_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_size_or_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_size_or_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_or_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_size_or_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_size_or_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_size_or_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def uchar_xor_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_uchar_xor_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uchar_xor_reduce_warpiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_xor_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uchar_xor_reduce_warpiPhPKhm_nbst = declare_device(
        '_ZL30nvshmemx_uchar_xor_reduce_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uchar_xor_reduce_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uchar_xor_reduce_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_xor_reduce_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uchar_xor_reduce_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uchar_xor_reduce_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uchar_xor_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_xor_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_ushort_xor_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_ushort_xor_reduce_warpiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_xor_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_ushort_xor_reduce_warpiPtPKtm_nbst = declare_device(
        '_ZL31nvshmemx_ushort_xor_reduce_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_ushort_xor_reduce_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_ushort_xor_reduce_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_xor_reduce_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_ushort_xor_reduce_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_ushort_xor_reduce_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_ushort_xor_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint_xor_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_uint_xor_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uint_xor_reduce_warpiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_xor_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_uint_xor_reduce_warpiPjPKjm_nbst = declare_device(
        '_ZL29nvshmemx_uint_xor_reduce_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_uint_xor_reduce_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_uint_xor_reduce_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_xor_reduce_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uint_xor_reduce_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uint_xor_reduce_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_uint_xor_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_xor_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_ulong_xor_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_ulong_xor_reduce_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_xor_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_ulong_xor_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL30nvshmemx_ulong_xor_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_ulong_xor_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_ulong_xor_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_xor_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_ulong_xor_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_ulong_xor_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_ulong_xor_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_xor_reduce_warp():
    pass
    

def _lower__ZL34nvshmemx_ulonglong_xor_reduce_warpiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmemx_ulonglong_xor_reduce_warpiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_xor_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmemx_ulonglong_xor_reduce_warpiPyPKym_nbst = declare_device(
        '_ZL34nvshmemx_ulonglong_xor_reduce_warpiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmemx_ulonglong_xor_reduce_warpiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmemx_ulonglong_xor_reduce_warpiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_xor_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmemx_ulonglong_xor_reduce_warpiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmemx_ulonglong_xor_reduce_warpiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmemx_ulonglong_xor_reduce_warpiPyPKym_nbst(shim_stream, shim_obj)


def int8_xor_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_int8_xor_reduce_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int8_xor_reduce_warpiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_xor_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_int8_xor_reduce_warpiPaPKam_nbst = declare_device(
        '_ZL29nvshmemx_int8_xor_reduce_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_int8_xor_reduce_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_int8_xor_reduce_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_xor_reduce_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int8_xor_reduce_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int8_xor_reduce_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_int8_xor_reduce_warpiPaPKam_nbst(shim_stream, shim_obj)


def int16_xor_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_int16_xor_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int16_xor_reduce_warpiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_xor_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int16_xor_reduce_warpiPsPKsm_nbst = declare_device(
        '_ZL30nvshmemx_int16_xor_reduce_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int16_xor_reduce_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int16_xor_reduce_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_xor_reduce_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int16_xor_reduce_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int16_xor_reduce_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int16_xor_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int32_xor_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_int32_xor_reduce_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int32_xor_reduce_warpiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_xor_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int32_xor_reduce_warpiPiPKim_nbst = declare_device(
        '_ZL30nvshmemx_int32_xor_reduce_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int32_xor_reduce_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int32_xor_reduce_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_xor_reduce_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int32_xor_reduce_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int32_xor_reduce_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int32_xor_reduce_warpiPiPKim_nbst(shim_stream, shim_obj)


def int64_xor_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_int64_xor_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int64_xor_reduce_warpiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_xor_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int64_xor_reduce_warpiPlPKlm_nbst = declare_device(
        '_ZL30nvshmemx_int64_xor_reduce_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int64_xor_reduce_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int64_xor_reduce_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_xor_reduce_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int64_xor_reduce_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int64_xor_reduce_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int64_xor_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_xor_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_uint8_xor_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint8_xor_reduce_warpiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_xor_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uint8_xor_reduce_warpiPhPKhm_nbst = declare_device(
        '_ZL30nvshmemx_uint8_xor_reduce_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint8_xor_reduce_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint8_xor_reduce_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_xor_reduce_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint8_xor_reduce_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint8_xor_reduce_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint8_xor_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_xor_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_uint16_xor_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint16_xor_reduce_warpiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_xor_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint16_xor_reduce_warpiPtPKtm_nbst = declare_device(
        '_ZL31nvshmemx_uint16_xor_reduce_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint16_xor_reduce_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint16_xor_reduce_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_xor_reduce_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint16_xor_reduce_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint16_xor_reduce_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint16_xor_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_xor_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_uint32_xor_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint32_xor_reduce_warpiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_xor_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint32_xor_reduce_warpiPjPKjm_nbst = declare_device(
        '_ZL31nvshmemx_uint32_xor_reduce_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint32_xor_reduce_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint32_xor_reduce_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_xor_reduce_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint32_xor_reduce_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint32_xor_reduce_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint32_xor_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_xor_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_uint64_xor_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint64_xor_reduce_warpiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_xor_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint64_xor_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL31nvshmemx_uint64_xor_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint64_xor_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint64_xor_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_xor_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint64_xor_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint64_xor_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint64_xor_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def size_xor_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_size_xor_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_size_xor_reduce_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_xor_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_size_xor_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL29nvshmemx_size_xor_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_size_xor_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_size_xor_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_xor_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_size_xor_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_size_xor_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_size_xor_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def uchar_max_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_uchar_max_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uchar_max_reduce_warpiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uchar_max_reduce_warpiPhPKhm_nbst = declare_device(
        '_ZL30nvshmemx_uchar_max_reduce_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uchar_max_reduce_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uchar_max_reduce_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_max_reduce_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uchar_max_reduce_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uchar_max_reduce_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uchar_max_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_max_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_ushort_max_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_ushort_max_reduce_warpiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_ushort_max_reduce_warpiPtPKtm_nbst = declare_device(
        '_ZL31nvshmemx_ushort_max_reduce_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_ushort_max_reduce_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_ushort_max_reduce_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_max_reduce_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_ushort_max_reduce_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_ushort_max_reduce_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_ushort_max_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint_max_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_uint_max_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uint_max_reduce_warpiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_uint_max_reduce_warpiPjPKjm_nbst = declare_device(
        '_ZL29nvshmemx_uint_max_reduce_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_uint_max_reduce_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_uint_max_reduce_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_max_reduce_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uint_max_reduce_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uint_max_reduce_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_uint_max_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_max_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_ulong_max_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_ulong_max_reduce_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_ulong_max_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL30nvshmemx_ulong_max_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_ulong_max_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_ulong_max_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_max_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_ulong_max_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_ulong_max_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_ulong_max_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_max_reduce_warp():
    pass
    

def _lower__ZL34nvshmemx_ulonglong_max_reduce_warpiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmemx_ulonglong_max_reduce_warpiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmemx_ulonglong_max_reduce_warpiPyPKym_nbst = declare_device(
        '_ZL34nvshmemx_ulonglong_max_reduce_warpiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmemx_ulonglong_max_reduce_warpiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmemx_ulonglong_max_reduce_warpiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_max_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmemx_ulonglong_max_reduce_warpiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmemx_ulonglong_max_reduce_warpiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmemx_ulonglong_max_reduce_warpiPyPKym_nbst(shim_stream, shim_obj)


def int8_max_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_int8_max_reduce_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int8_max_reduce_warpiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_int8_max_reduce_warpiPaPKam_nbst = declare_device(
        '_ZL29nvshmemx_int8_max_reduce_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_int8_max_reduce_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_int8_max_reduce_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_max_reduce_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int8_max_reduce_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int8_max_reduce_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_int8_max_reduce_warpiPaPKam_nbst(shim_stream, shim_obj)


def int16_max_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_int16_max_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int16_max_reduce_warpiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int16_max_reduce_warpiPsPKsm_nbst = declare_device(
        '_ZL30nvshmemx_int16_max_reduce_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int16_max_reduce_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int16_max_reduce_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_max_reduce_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int16_max_reduce_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int16_max_reduce_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int16_max_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int32_max_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_int32_max_reduce_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int32_max_reduce_warpiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int32_max_reduce_warpiPiPKim_nbst = declare_device(
        '_ZL30nvshmemx_int32_max_reduce_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int32_max_reduce_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int32_max_reduce_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_max_reduce_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int32_max_reduce_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int32_max_reduce_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int32_max_reduce_warpiPiPKim_nbst(shim_stream, shim_obj)


def int64_max_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_int64_max_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int64_max_reduce_warpiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int64_max_reduce_warpiPlPKlm_nbst = declare_device(
        '_ZL30nvshmemx_int64_max_reduce_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int64_max_reduce_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int64_max_reduce_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_max_reduce_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int64_max_reduce_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int64_max_reduce_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int64_max_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_max_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_uint8_max_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint8_max_reduce_warpiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uint8_max_reduce_warpiPhPKhm_nbst = declare_device(
        '_ZL30nvshmemx_uint8_max_reduce_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint8_max_reduce_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint8_max_reduce_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_max_reduce_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint8_max_reduce_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint8_max_reduce_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint8_max_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_max_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_uint16_max_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint16_max_reduce_warpiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint16_max_reduce_warpiPtPKtm_nbst = declare_device(
        '_ZL31nvshmemx_uint16_max_reduce_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint16_max_reduce_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint16_max_reduce_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_max_reduce_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint16_max_reduce_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint16_max_reduce_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint16_max_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_max_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_uint32_max_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint32_max_reduce_warpiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint32_max_reduce_warpiPjPKjm_nbst = declare_device(
        '_ZL31nvshmemx_uint32_max_reduce_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint32_max_reduce_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint32_max_reduce_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_max_reduce_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint32_max_reduce_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint32_max_reduce_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint32_max_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_max_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_uint64_max_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint64_max_reduce_warpiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint64_max_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL31nvshmemx_uint64_max_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint64_max_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint64_max_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_max_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint64_max_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint64_max_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint64_max_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def size_max_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_size_max_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_size_max_reduce_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_size_max_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL29nvshmemx_size_max_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_size_max_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_size_max_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_max_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_size_max_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_size_max_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_size_max_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def char_max_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_char_max_reduce_warpiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_char_max_reduce_warpiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmemx_char_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_char_max_reduce_warpiPcPKcm_nbst = declare_device(
        '_ZL29nvshmemx_char_max_reduce_warpiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_char_max_reduce_warpiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_char_max_reduce_warpiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_max_reduce_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_char_max_reduce_warpiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_char_max_reduce_warpiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_char_max_reduce_warpiPcPKcm_nbst(shim_stream, shim_obj)


def schar_max_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_schar_max_reduce_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_schar_max_reduce_warpiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmemx_schar_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_schar_max_reduce_warpiPaPKam_nbst = declare_device(
        '_ZL30nvshmemx_schar_max_reduce_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_schar_max_reduce_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_schar_max_reduce_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_max_reduce_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_schar_max_reduce_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_schar_max_reduce_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_schar_max_reduce_warpiPaPKam_nbst(shim_stream, shim_obj)


def short_max_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_short_max_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_short_max_reduce_warpiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmemx_short_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_short_max_reduce_warpiPsPKsm_nbst = declare_device(
        '_ZL30nvshmemx_short_max_reduce_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_short_max_reduce_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_short_max_reduce_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_max_reduce_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_short_max_reduce_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_short_max_reduce_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_short_max_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int_max_reduce_warp():
    pass
    

def _lower__ZL28nvshmemx_int_max_reduce_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_int_max_reduce_warpiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmemx_int_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL28nvshmemx_int_max_reduce_warpiPiPKim_nbst = declare_device(
        '_ZL28nvshmemx_int_max_reduce_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_int_max_reduce_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_int_max_reduce_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_max_reduce_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_int_max_reduce_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_int_max_reduce_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_int_max_reduce_warpiPiPKim_nbst(shim_stream, shim_obj)


def long_max_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_long_max_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_long_max_reduce_warpiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmemx_long_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_long_max_reduce_warpiPlPKlm_nbst = declare_device(
        '_ZL29nvshmemx_long_max_reduce_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_long_max_reduce_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_long_max_reduce_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_max_reduce_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_long_max_reduce_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_long_max_reduce_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_long_max_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_max_reduce_warp():
    pass
    

def _lower__ZL33nvshmemx_longlong_max_reduce_warpiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmemx_longlong_max_reduce_warpiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_longlong_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL33nvshmemx_longlong_max_reduce_warpiPxPKxm_nbst = declare_device(
        '_ZL33nvshmemx_longlong_max_reduce_warpiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL33nvshmemx_longlong_max_reduce_warpiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL33nvshmemx_longlong_max_reduce_warpiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_max_reduce_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmemx_longlong_max_reduce_warpiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmemx_longlong_max_reduce_warpiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL33nvshmemx_longlong_max_reduce_warpiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_max_reduce_warp():
    pass
    

def _lower__ZL33nvshmemx_bfloat16_max_reduce_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmemx_bfloat16_max_reduce_warpiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmemx_bfloat16_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL33nvshmemx_bfloat16_max_reduce_warpiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL33nvshmemx_bfloat16_max_reduce_warpiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL33nvshmemx_bfloat16_max_reduce_warpiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL33nvshmemx_bfloat16_max_reduce_warpiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_max_reduce_warp, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmemx_bfloat16_max_reduce_warpiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmemx_bfloat16_max_reduce_warpiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL33nvshmemx_bfloat16_max_reduce_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_max_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_half_max_reduce_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_half_max_reduce_warpiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmemx_half_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_half_max_reduce_warpiP6__halfPKS_m_nbst = declare_device(
        '_ZL29nvshmemx_half_max_reduce_warpiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_half_max_reduce_warpiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_half_max_reduce_warpiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_max_reduce_warp, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_half_max_reduce_warpiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_half_max_reduce_warpiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_half_max_reduce_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_max_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_float_max_reduce_warpiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_float_max_reduce_warpiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmemx_float_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_float_max_reduce_warpiPfPKfm_nbst = declare_device(
        '_ZL30nvshmemx_float_max_reduce_warpiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_float_max_reduce_warpiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_float_max_reduce_warpiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_max_reduce_warp, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_float_max_reduce_warpiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_float_max_reduce_warpiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_float_max_reduce_warpiPfPKfm_nbst(shim_stream, shim_obj)


def double_max_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_double_max_reduce_warpiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_double_max_reduce_warpiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmemx_double_max_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_double_max_reduce_warpiPdPKdm_nbst = declare_device(
        '_ZL31nvshmemx_double_max_reduce_warpiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_double_max_reduce_warpiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_double_max_reduce_warpiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_max_reduce_warp, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_double_max_reduce_warpiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_double_max_reduce_warpiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_double_max_reduce_warpiPdPKdm_nbst(shim_stream, shim_obj)


def uchar_min_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_uchar_min_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uchar_min_reduce_warpiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uchar_min_reduce_warpiPhPKhm_nbst = declare_device(
        '_ZL30nvshmemx_uchar_min_reduce_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uchar_min_reduce_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uchar_min_reduce_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_min_reduce_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uchar_min_reduce_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uchar_min_reduce_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uchar_min_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_min_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_ushort_min_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_ushort_min_reduce_warpiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_ushort_min_reduce_warpiPtPKtm_nbst = declare_device(
        '_ZL31nvshmemx_ushort_min_reduce_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_ushort_min_reduce_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_ushort_min_reduce_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_min_reduce_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_ushort_min_reduce_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_ushort_min_reduce_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_ushort_min_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint_min_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_uint_min_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uint_min_reduce_warpiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_uint_min_reduce_warpiPjPKjm_nbst = declare_device(
        '_ZL29nvshmemx_uint_min_reduce_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_uint_min_reduce_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_uint_min_reduce_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_min_reduce_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uint_min_reduce_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uint_min_reduce_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_uint_min_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_min_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_ulong_min_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_ulong_min_reduce_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_ulong_min_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL30nvshmemx_ulong_min_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_ulong_min_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_ulong_min_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_min_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_ulong_min_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_ulong_min_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_ulong_min_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_min_reduce_warp():
    pass
    

def _lower__ZL34nvshmemx_ulonglong_min_reduce_warpiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmemx_ulonglong_min_reduce_warpiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmemx_ulonglong_min_reduce_warpiPyPKym_nbst = declare_device(
        '_ZL34nvshmemx_ulonglong_min_reduce_warpiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmemx_ulonglong_min_reduce_warpiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmemx_ulonglong_min_reduce_warpiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_min_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmemx_ulonglong_min_reduce_warpiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmemx_ulonglong_min_reduce_warpiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmemx_ulonglong_min_reduce_warpiPyPKym_nbst(shim_stream, shim_obj)


def int8_min_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_int8_min_reduce_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int8_min_reduce_warpiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_int8_min_reduce_warpiPaPKam_nbst = declare_device(
        '_ZL29nvshmemx_int8_min_reduce_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_int8_min_reduce_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_int8_min_reduce_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_min_reduce_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int8_min_reduce_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int8_min_reduce_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_int8_min_reduce_warpiPaPKam_nbst(shim_stream, shim_obj)


def int16_min_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_int16_min_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int16_min_reduce_warpiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int16_min_reduce_warpiPsPKsm_nbst = declare_device(
        '_ZL30nvshmemx_int16_min_reduce_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int16_min_reduce_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int16_min_reduce_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_min_reduce_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int16_min_reduce_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int16_min_reduce_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int16_min_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int32_min_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_int32_min_reduce_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int32_min_reduce_warpiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int32_min_reduce_warpiPiPKim_nbst = declare_device(
        '_ZL30nvshmemx_int32_min_reduce_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int32_min_reduce_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int32_min_reduce_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_min_reduce_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int32_min_reduce_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int32_min_reduce_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int32_min_reduce_warpiPiPKim_nbst(shim_stream, shim_obj)


def int64_min_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_int64_min_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int64_min_reduce_warpiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int64_min_reduce_warpiPlPKlm_nbst = declare_device(
        '_ZL30nvshmemx_int64_min_reduce_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int64_min_reduce_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int64_min_reduce_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_min_reduce_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int64_min_reduce_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int64_min_reduce_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int64_min_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_min_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_uint8_min_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint8_min_reduce_warpiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uint8_min_reduce_warpiPhPKhm_nbst = declare_device(
        '_ZL30nvshmemx_uint8_min_reduce_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint8_min_reduce_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint8_min_reduce_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_min_reduce_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint8_min_reduce_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint8_min_reduce_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint8_min_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_min_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_uint16_min_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint16_min_reduce_warpiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint16_min_reduce_warpiPtPKtm_nbst = declare_device(
        '_ZL31nvshmemx_uint16_min_reduce_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint16_min_reduce_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint16_min_reduce_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_min_reduce_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint16_min_reduce_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint16_min_reduce_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint16_min_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_min_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_uint32_min_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint32_min_reduce_warpiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint32_min_reduce_warpiPjPKjm_nbst = declare_device(
        '_ZL31nvshmemx_uint32_min_reduce_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint32_min_reduce_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint32_min_reduce_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_min_reduce_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint32_min_reduce_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint32_min_reduce_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint32_min_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_min_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_uint64_min_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint64_min_reduce_warpiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint64_min_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL31nvshmemx_uint64_min_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint64_min_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint64_min_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_min_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint64_min_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint64_min_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint64_min_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def size_min_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_size_min_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_size_min_reduce_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_size_min_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL29nvshmemx_size_min_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_size_min_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_size_min_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_min_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_size_min_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_size_min_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_size_min_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def char_min_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_char_min_reduce_warpiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_char_min_reduce_warpiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmemx_char_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_char_min_reduce_warpiPcPKcm_nbst = declare_device(
        '_ZL29nvshmemx_char_min_reduce_warpiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_char_min_reduce_warpiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_char_min_reduce_warpiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_min_reduce_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_char_min_reduce_warpiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_char_min_reduce_warpiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_char_min_reduce_warpiPcPKcm_nbst(shim_stream, shim_obj)


def schar_min_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_schar_min_reduce_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_schar_min_reduce_warpiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmemx_schar_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_schar_min_reduce_warpiPaPKam_nbst = declare_device(
        '_ZL30nvshmemx_schar_min_reduce_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_schar_min_reduce_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_schar_min_reduce_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_min_reduce_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_schar_min_reduce_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_schar_min_reduce_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_schar_min_reduce_warpiPaPKam_nbst(shim_stream, shim_obj)


def short_min_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_short_min_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_short_min_reduce_warpiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmemx_short_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_short_min_reduce_warpiPsPKsm_nbst = declare_device(
        '_ZL30nvshmemx_short_min_reduce_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_short_min_reduce_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_short_min_reduce_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_min_reduce_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_short_min_reduce_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_short_min_reduce_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_short_min_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int_min_reduce_warp():
    pass
    

def _lower__ZL28nvshmemx_int_min_reduce_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_int_min_reduce_warpiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmemx_int_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL28nvshmemx_int_min_reduce_warpiPiPKim_nbst = declare_device(
        '_ZL28nvshmemx_int_min_reduce_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_int_min_reduce_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_int_min_reduce_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_min_reduce_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_int_min_reduce_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_int_min_reduce_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_int_min_reduce_warpiPiPKim_nbst(shim_stream, shim_obj)


def long_min_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_long_min_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_long_min_reduce_warpiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmemx_long_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_long_min_reduce_warpiPlPKlm_nbst = declare_device(
        '_ZL29nvshmemx_long_min_reduce_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_long_min_reduce_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_long_min_reduce_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_min_reduce_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_long_min_reduce_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_long_min_reduce_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_long_min_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_min_reduce_warp():
    pass
    

def _lower__ZL33nvshmemx_longlong_min_reduce_warpiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmemx_longlong_min_reduce_warpiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_longlong_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL33nvshmemx_longlong_min_reduce_warpiPxPKxm_nbst = declare_device(
        '_ZL33nvshmemx_longlong_min_reduce_warpiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL33nvshmemx_longlong_min_reduce_warpiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL33nvshmemx_longlong_min_reduce_warpiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_min_reduce_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmemx_longlong_min_reduce_warpiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmemx_longlong_min_reduce_warpiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL33nvshmemx_longlong_min_reduce_warpiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_min_reduce_warp():
    pass
    

def _lower__ZL33nvshmemx_bfloat16_min_reduce_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmemx_bfloat16_min_reduce_warpiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmemx_bfloat16_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL33nvshmemx_bfloat16_min_reduce_warpiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL33nvshmemx_bfloat16_min_reduce_warpiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL33nvshmemx_bfloat16_min_reduce_warpiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL33nvshmemx_bfloat16_min_reduce_warpiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_min_reduce_warp, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmemx_bfloat16_min_reduce_warpiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmemx_bfloat16_min_reduce_warpiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL33nvshmemx_bfloat16_min_reduce_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_min_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_half_min_reduce_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_half_min_reduce_warpiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmemx_half_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_half_min_reduce_warpiP6__halfPKS_m_nbst = declare_device(
        '_ZL29nvshmemx_half_min_reduce_warpiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_half_min_reduce_warpiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_half_min_reduce_warpiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_min_reduce_warp, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_half_min_reduce_warpiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_half_min_reduce_warpiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_half_min_reduce_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_min_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_float_min_reduce_warpiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_float_min_reduce_warpiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmemx_float_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_float_min_reduce_warpiPfPKfm_nbst = declare_device(
        '_ZL30nvshmemx_float_min_reduce_warpiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_float_min_reduce_warpiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_float_min_reduce_warpiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_min_reduce_warp, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_float_min_reduce_warpiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_float_min_reduce_warpiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_float_min_reduce_warpiPfPKfm_nbst(shim_stream, shim_obj)


def double_min_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_double_min_reduce_warpiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_double_min_reduce_warpiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmemx_double_min_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_double_min_reduce_warpiPdPKdm_nbst = declare_device(
        '_ZL31nvshmemx_double_min_reduce_warpiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_double_min_reduce_warpiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_double_min_reduce_warpiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_min_reduce_warp, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_double_min_reduce_warpiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_double_min_reduce_warpiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_double_min_reduce_warpiPdPKdm_nbst(shim_stream, shim_obj)


def uchar_sum_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_uchar_sum_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uchar_sum_reduce_warpiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uchar_sum_reduce_warpiPhPKhm_nbst = declare_device(
        '_ZL30nvshmemx_uchar_sum_reduce_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uchar_sum_reduce_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uchar_sum_reduce_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_sum_reduce_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uchar_sum_reduce_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uchar_sum_reduce_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uchar_sum_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_sum_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_ushort_sum_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_ushort_sum_reduce_warpiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_ushort_sum_reduce_warpiPtPKtm_nbst = declare_device(
        '_ZL31nvshmemx_ushort_sum_reduce_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_ushort_sum_reduce_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_ushort_sum_reduce_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_sum_reduce_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_ushort_sum_reduce_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_ushort_sum_reduce_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_ushort_sum_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint_sum_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_uint_sum_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uint_sum_reduce_warpiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_uint_sum_reduce_warpiPjPKjm_nbst = declare_device(
        '_ZL29nvshmemx_uint_sum_reduce_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_uint_sum_reduce_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_uint_sum_reduce_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_sum_reduce_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uint_sum_reduce_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uint_sum_reduce_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_uint_sum_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_sum_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_ulong_sum_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_ulong_sum_reduce_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_ulong_sum_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL30nvshmemx_ulong_sum_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_ulong_sum_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_ulong_sum_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_sum_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_ulong_sum_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_ulong_sum_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_ulong_sum_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_sum_reduce_warp():
    pass
    

def _lower__ZL34nvshmemx_ulonglong_sum_reduce_warpiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmemx_ulonglong_sum_reduce_warpiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmemx_ulonglong_sum_reduce_warpiPyPKym_nbst = declare_device(
        '_ZL34nvshmemx_ulonglong_sum_reduce_warpiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmemx_ulonglong_sum_reduce_warpiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmemx_ulonglong_sum_reduce_warpiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_sum_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmemx_ulonglong_sum_reduce_warpiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmemx_ulonglong_sum_reduce_warpiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmemx_ulonglong_sum_reduce_warpiPyPKym_nbst(shim_stream, shim_obj)


def int8_sum_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_int8_sum_reduce_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int8_sum_reduce_warpiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_int8_sum_reduce_warpiPaPKam_nbst = declare_device(
        '_ZL29nvshmemx_int8_sum_reduce_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_int8_sum_reduce_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_int8_sum_reduce_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_sum_reduce_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int8_sum_reduce_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int8_sum_reduce_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_int8_sum_reduce_warpiPaPKam_nbst(shim_stream, shim_obj)


def int16_sum_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_int16_sum_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int16_sum_reduce_warpiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int16_sum_reduce_warpiPsPKsm_nbst = declare_device(
        '_ZL30nvshmemx_int16_sum_reduce_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int16_sum_reduce_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int16_sum_reduce_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_sum_reduce_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int16_sum_reduce_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int16_sum_reduce_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int16_sum_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int32_sum_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_int32_sum_reduce_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int32_sum_reduce_warpiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int32_sum_reduce_warpiPiPKim_nbst = declare_device(
        '_ZL30nvshmemx_int32_sum_reduce_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int32_sum_reduce_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int32_sum_reduce_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_sum_reduce_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int32_sum_reduce_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int32_sum_reduce_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int32_sum_reduce_warpiPiPKim_nbst(shim_stream, shim_obj)


def int64_sum_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_int64_sum_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int64_sum_reduce_warpiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int64_sum_reduce_warpiPlPKlm_nbst = declare_device(
        '_ZL30nvshmemx_int64_sum_reduce_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int64_sum_reduce_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int64_sum_reduce_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_sum_reduce_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int64_sum_reduce_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int64_sum_reduce_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int64_sum_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_sum_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_uint8_sum_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint8_sum_reduce_warpiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uint8_sum_reduce_warpiPhPKhm_nbst = declare_device(
        '_ZL30nvshmemx_uint8_sum_reduce_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint8_sum_reduce_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint8_sum_reduce_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_sum_reduce_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint8_sum_reduce_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint8_sum_reduce_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint8_sum_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_sum_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_uint16_sum_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint16_sum_reduce_warpiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint16_sum_reduce_warpiPtPKtm_nbst = declare_device(
        '_ZL31nvshmemx_uint16_sum_reduce_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint16_sum_reduce_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint16_sum_reduce_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_sum_reduce_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint16_sum_reduce_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint16_sum_reduce_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint16_sum_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_sum_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_uint32_sum_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint32_sum_reduce_warpiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint32_sum_reduce_warpiPjPKjm_nbst = declare_device(
        '_ZL31nvshmemx_uint32_sum_reduce_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint32_sum_reduce_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint32_sum_reduce_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_sum_reduce_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint32_sum_reduce_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint32_sum_reduce_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint32_sum_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_sum_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_uint64_sum_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint64_sum_reduce_warpiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint64_sum_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL31nvshmemx_uint64_sum_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint64_sum_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint64_sum_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_sum_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint64_sum_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint64_sum_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint64_sum_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def size_sum_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_size_sum_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_size_sum_reduce_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_size_sum_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL29nvshmemx_size_sum_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_size_sum_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_size_sum_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_sum_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_size_sum_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_size_sum_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_size_sum_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def char_sum_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_char_sum_reduce_warpiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_char_sum_reduce_warpiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmemx_char_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_char_sum_reduce_warpiPcPKcm_nbst = declare_device(
        '_ZL29nvshmemx_char_sum_reduce_warpiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_char_sum_reduce_warpiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_char_sum_reduce_warpiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_sum_reduce_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_char_sum_reduce_warpiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_char_sum_reduce_warpiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_char_sum_reduce_warpiPcPKcm_nbst(shim_stream, shim_obj)


def schar_sum_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_schar_sum_reduce_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_schar_sum_reduce_warpiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmemx_schar_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_schar_sum_reduce_warpiPaPKam_nbst = declare_device(
        '_ZL30nvshmemx_schar_sum_reduce_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_schar_sum_reduce_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_schar_sum_reduce_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_sum_reduce_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_schar_sum_reduce_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_schar_sum_reduce_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_schar_sum_reduce_warpiPaPKam_nbst(shim_stream, shim_obj)


def short_sum_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_short_sum_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_short_sum_reduce_warpiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmemx_short_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_short_sum_reduce_warpiPsPKsm_nbst = declare_device(
        '_ZL30nvshmemx_short_sum_reduce_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_short_sum_reduce_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_short_sum_reduce_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_sum_reduce_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_short_sum_reduce_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_short_sum_reduce_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_short_sum_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int_sum_reduce_warp():
    pass
    

def _lower__ZL28nvshmemx_int_sum_reduce_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL28nvshmemx_int_sum_reduce_warpiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmemx_int_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL28nvshmemx_int_sum_reduce_warpiPiPKim_nbst = declare_device(
        '_ZL28nvshmemx_int_sum_reduce_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL28nvshmemx_int_sum_reduce_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL28nvshmemx_int_sum_reduce_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_sum_reduce_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL28nvshmemx_int_sum_reduce_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL28nvshmemx_int_sum_reduce_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL28nvshmemx_int_sum_reduce_warpiPiPKim_nbst(shim_stream, shim_obj)


def long_sum_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_long_sum_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_long_sum_reduce_warpiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmemx_long_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_long_sum_reduce_warpiPlPKlm_nbst = declare_device(
        '_ZL29nvshmemx_long_sum_reduce_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_long_sum_reduce_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_long_sum_reduce_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_sum_reduce_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_long_sum_reduce_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_long_sum_reduce_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_long_sum_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_sum_reduce_warp():
    pass
    

def _lower__ZL33nvshmemx_longlong_sum_reduce_warpiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmemx_longlong_sum_reduce_warpiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_longlong_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL33nvshmemx_longlong_sum_reduce_warpiPxPKxm_nbst = declare_device(
        '_ZL33nvshmemx_longlong_sum_reduce_warpiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL33nvshmemx_longlong_sum_reduce_warpiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL33nvshmemx_longlong_sum_reduce_warpiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_sum_reduce_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmemx_longlong_sum_reduce_warpiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmemx_longlong_sum_reduce_warpiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL33nvshmemx_longlong_sum_reduce_warpiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_sum_reduce_warp():
    pass
    

def _lower__ZL33nvshmemx_bfloat16_sum_reduce_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmemx_bfloat16_sum_reduce_warpiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmemx_bfloat16_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL33nvshmemx_bfloat16_sum_reduce_warpiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL33nvshmemx_bfloat16_sum_reduce_warpiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL33nvshmemx_bfloat16_sum_reduce_warpiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL33nvshmemx_bfloat16_sum_reduce_warpiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_sum_reduce_warp, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmemx_bfloat16_sum_reduce_warpiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmemx_bfloat16_sum_reduce_warpiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL33nvshmemx_bfloat16_sum_reduce_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_sum_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_half_sum_reduce_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_half_sum_reduce_warpiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmemx_half_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_half_sum_reduce_warpiP6__halfPKS_m_nbst = declare_device(
        '_ZL29nvshmemx_half_sum_reduce_warpiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_half_sum_reduce_warpiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_half_sum_reduce_warpiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_sum_reduce_warp, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_half_sum_reduce_warpiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_half_sum_reduce_warpiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_half_sum_reduce_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_sum_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_float_sum_reduce_warpiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_float_sum_reduce_warpiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmemx_float_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_float_sum_reduce_warpiPfPKfm_nbst = declare_device(
        '_ZL30nvshmemx_float_sum_reduce_warpiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_float_sum_reduce_warpiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_float_sum_reduce_warpiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_sum_reduce_warp, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_float_sum_reduce_warpiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_float_sum_reduce_warpiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_float_sum_reduce_warpiPfPKfm_nbst(shim_stream, shim_obj)


def double_sum_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_double_sum_reduce_warpiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_double_sum_reduce_warpiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmemx_double_sum_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_double_sum_reduce_warpiPdPKdm_nbst = declare_device(
        '_ZL31nvshmemx_double_sum_reduce_warpiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_double_sum_reduce_warpiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_double_sum_reduce_warpiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_sum_reduce_warp, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_double_sum_reduce_warpiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_double_sum_reduce_warpiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_double_sum_reduce_warpiPdPKdm_nbst(shim_stream, shim_obj)


def uchar_prod_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_uchar_prod_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uchar_prod_reduce_warpiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uchar_prod_reduce_warpiPhPKhm_nbst = declare_device(
        '_ZL31nvshmemx_uchar_prod_reduce_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uchar_prod_reduce_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uchar_prod_reduce_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_prod_reduce_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uchar_prod_reduce_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uchar_prod_reduce_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uchar_prod_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_prod_reduce_warp():
    pass
    

def _lower__ZL32nvshmemx_ushort_prod_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_ushort_prod_reduce_warpiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_ushort_prod_reduce_warpiPtPKtm_nbst = declare_device(
        '_ZL32nvshmemx_ushort_prod_reduce_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_ushort_prod_reduce_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_ushort_prod_reduce_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_prod_reduce_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_ushort_prod_reduce_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_ushort_prod_reduce_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_ushort_prod_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint_prod_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_uint_prod_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint_prod_reduce_warpiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uint_prod_reduce_warpiPjPKjm_nbst = declare_device(
        '_ZL30nvshmemx_uint_prod_reduce_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint_prod_reduce_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint_prod_reduce_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_prod_reduce_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint_prod_reduce_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint_prod_reduce_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint_prod_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_prod_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_ulong_prod_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_ulong_prod_reduce_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_ulong_prod_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL31nvshmemx_ulong_prod_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_ulong_prod_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_ulong_prod_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_prod_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_ulong_prod_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_ulong_prod_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_ulong_prod_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_prod_reduce_warp():
    pass
    

def _lower__ZL35nvshmemx_ulonglong_prod_reduce_warpiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmemx_ulonglong_prod_reduce_warpiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmemx_ulonglong_prod_reduce_warpiPyPKym_nbst = declare_device(
        '_ZL35nvshmemx_ulonglong_prod_reduce_warpiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmemx_ulonglong_prod_reduce_warpiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmemx_ulonglong_prod_reduce_warpiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_prod_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL35nvshmemx_ulonglong_prod_reduce_warpiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmemx_ulonglong_prod_reduce_warpiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmemx_ulonglong_prod_reduce_warpiPyPKym_nbst(shim_stream, shim_obj)


def int8_prod_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_int8_prod_reduce_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int8_prod_reduce_warpiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int8_prod_reduce_warpiPaPKam_nbst = declare_device(
        '_ZL30nvshmemx_int8_prod_reduce_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int8_prod_reduce_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int8_prod_reduce_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_prod_reduce_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int8_prod_reduce_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int8_prod_reduce_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int8_prod_reduce_warpiPaPKam_nbst(shim_stream, shim_obj)


def int16_prod_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_int16_prod_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_int16_prod_reduce_warpiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_int16_prod_reduce_warpiPsPKsm_nbst = declare_device(
        '_ZL31nvshmemx_int16_prod_reduce_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_int16_prod_reduce_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_int16_prod_reduce_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_prod_reduce_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_int16_prod_reduce_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_int16_prod_reduce_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_int16_prod_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int32_prod_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_int32_prod_reduce_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_int32_prod_reduce_warpiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_int32_prod_reduce_warpiPiPKim_nbst = declare_device(
        '_ZL31nvshmemx_int32_prod_reduce_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_int32_prod_reduce_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_int32_prod_reduce_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_prod_reduce_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_int32_prod_reduce_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_int32_prod_reduce_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_int32_prod_reduce_warpiPiPKim_nbst(shim_stream, shim_obj)


def int64_prod_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_int64_prod_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_int64_prod_reduce_warpiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_int64_prod_reduce_warpiPlPKlm_nbst = declare_device(
        '_ZL31nvshmemx_int64_prod_reduce_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_int64_prod_reduce_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_int64_prod_reduce_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_prod_reduce_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_int64_prod_reduce_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_int64_prod_reduce_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_int64_prod_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_prod_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_uint8_prod_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint8_prod_reduce_warpiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint8_prod_reduce_warpiPhPKhm_nbst = declare_device(
        '_ZL31nvshmemx_uint8_prod_reduce_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint8_prod_reduce_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint8_prod_reduce_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_prod_reduce_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint8_prod_reduce_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint8_prod_reduce_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint8_prod_reduce_warpiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_prod_reduce_warp():
    pass
    

def _lower__ZL32nvshmemx_uint16_prod_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uint16_prod_reduce_warpiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uint16_prod_reduce_warpiPtPKtm_nbst = declare_device(
        '_ZL32nvshmemx_uint16_prod_reduce_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uint16_prod_reduce_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uint16_prod_reduce_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_prod_reduce_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uint16_prod_reduce_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uint16_prod_reduce_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uint16_prod_reduce_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_prod_reduce_warp():
    pass
    

def _lower__ZL32nvshmemx_uint32_prod_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uint32_prod_reduce_warpiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uint32_prod_reduce_warpiPjPKjm_nbst = declare_device(
        '_ZL32nvshmemx_uint32_prod_reduce_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uint32_prod_reduce_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uint32_prod_reduce_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_prod_reduce_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uint32_prod_reduce_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uint32_prod_reduce_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uint32_prod_reduce_warpiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_prod_reduce_warp():
    pass
    

def _lower__ZL32nvshmemx_uint64_prod_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uint64_prod_reduce_warpiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uint64_prod_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL32nvshmemx_uint64_prod_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uint64_prod_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uint64_prod_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_prod_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uint64_prod_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uint64_prod_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uint64_prod_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def size_prod_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_size_prod_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_size_prod_reduce_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_size_prod_reduce_warpiPmPKmm_nbst = declare_device(
        '_ZL30nvshmemx_size_prod_reduce_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_size_prod_reduce_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_size_prod_reduce_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_prod_reduce_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_size_prod_reduce_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_size_prod_reduce_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_size_prod_reduce_warpiPmPKmm_nbst(shim_stream, shim_obj)


def char_prod_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_char_prod_reduce_warpiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_char_prod_reduce_warpiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmemx_char_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_char_prod_reduce_warpiPcPKcm_nbst = declare_device(
        '_ZL30nvshmemx_char_prod_reduce_warpiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_char_prod_reduce_warpiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_char_prod_reduce_warpiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_prod_reduce_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_char_prod_reduce_warpiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_char_prod_reduce_warpiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_char_prod_reduce_warpiPcPKcm_nbst(shim_stream, shim_obj)


def schar_prod_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_schar_prod_reduce_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_schar_prod_reduce_warpiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmemx_schar_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_schar_prod_reduce_warpiPaPKam_nbst = declare_device(
        '_ZL31nvshmemx_schar_prod_reduce_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_schar_prod_reduce_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_schar_prod_reduce_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_prod_reduce_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_schar_prod_reduce_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_schar_prod_reduce_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_schar_prod_reduce_warpiPaPKam_nbst(shim_stream, shim_obj)


def short_prod_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_short_prod_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_short_prod_reduce_warpiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmemx_short_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_short_prod_reduce_warpiPsPKsm_nbst = declare_device(
        '_ZL31nvshmemx_short_prod_reduce_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_short_prod_reduce_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_short_prod_reduce_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_prod_reduce_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_short_prod_reduce_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_short_prod_reduce_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_short_prod_reduce_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int_prod_reduce_warp():
    pass
    

def _lower__ZL29nvshmemx_int_prod_reduce_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int_prod_reduce_warpiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmemx_int_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_int_prod_reduce_warpiPiPKim_nbst = declare_device(
        '_ZL29nvshmemx_int_prod_reduce_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_int_prod_reduce_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_int_prod_reduce_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_prod_reduce_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int_prod_reduce_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int_prod_reduce_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_int_prod_reduce_warpiPiPKim_nbst(shim_stream, shim_obj)


def long_prod_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_long_prod_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_long_prod_reduce_warpiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmemx_long_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_long_prod_reduce_warpiPlPKlm_nbst = declare_device(
        '_ZL30nvshmemx_long_prod_reduce_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_long_prod_reduce_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_long_prod_reduce_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_prod_reduce_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_long_prod_reduce_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_long_prod_reduce_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_long_prod_reduce_warpiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_prod_reduce_warp():
    pass
    

def _lower__ZL34nvshmemx_longlong_prod_reduce_warpiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmemx_longlong_prod_reduce_warpiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_longlong_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmemx_longlong_prod_reduce_warpiPxPKxm_nbst = declare_device(
        '_ZL34nvshmemx_longlong_prod_reduce_warpiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmemx_longlong_prod_reduce_warpiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmemx_longlong_prod_reduce_warpiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_prod_reduce_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmemx_longlong_prod_reduce_warpiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmemx_longlong_prod_reduce_warpiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmemx_longlong_prod_reduce_warpiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_prod_reduce_warp():
    pass
    

def _lower__ZL34nvshmemx_bfloat16_prod_reduce_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmemx_bfloat16_prod_reduce_warpiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmemx_bfloat16_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmemx_bfloat16_prod_reduce_warpiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL34nvshmemx_bfloat16_prod_reduce_warpiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmemx_bfloat16_prod_reduce_warpiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmemx_bfloat16_prod_reduce_warpiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_prod_reduce_warp, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmemx_bfloat16_prod_reduce_warpiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmemx_bfloat16_prod_reduce_warpiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmemx_bfloat16_prod_reduce_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_prod_reduce_warp():
    pass
    

def _lower__ZL30nvshmemx_half_prod_reduce_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_half_prod_reduce_warpiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmemx_half_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_half_prod_reduce_warpiP6__halfPKS_m_nbst = declare_device(
        '_ZL30nvshmemx_half_prod_reduce_warpiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_half_prod_reduce_warpiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_half_prod_reduce_warpiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_prod_reduce_warp, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_half_prod_reduce_warpiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_half_prod_reduce_warpiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_half_prod_reduce_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_prod_reduce_warp():
    pass
    

def _lower__ZL31nvshmemx_float_prod_reduce_warpiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_float_prod_reduce_warpiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmemx_float_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_float_prod_reduce_warpiPfPKfm_nbst = declare_device(
        '_ZL31nvshmemx_float_prod_reduce_warpiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_float_prod_reduce_warpiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_float_prod_reduce_warpiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_prod_reduce_warp, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_float_prod_reduce_warpiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_float_prod_reduce_warpiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_float_prod_reduce_warpiPfPKfm_nbst(shim_stream, shim_obj)


def double_prod_reduce_warp():
    pass
    

def _lower__ZL32nvshmemx_double_prod_reduce_warpiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_double_prod_reduce_warpiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmemx_double_prod_reduce_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_double_prod_reduce_warpiPdPKdm_nbst = declare_device(
        '_ZL32nvshmemx_double_prod_reduce_warpiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_double_prod_reduce_warpiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_double_prod_reduce_warpiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_prod_reduce_warp, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_double_prod_reduce_warpiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_double_prod_reduce_warpiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_double_prod_reduce_warpiPdPKdm_nbst(shim_stream, shim_obj)


def uchar_and_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_uchar_and_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uchar_and_reduce_blockiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_and_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uchar_and_reduce_blockiPhPKhm_nbst = declare_device(
        '_ZL31nvshmemx_uchar_and_reduce_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uchar_and_reduce_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uchar_and_reduce_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_and_reduce_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uchar_and_reduce_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uchar_and_reduce_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uchar_and_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_and_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_ushort_and_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_ushort_and_reduce_blockiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_and_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_ushort_and_reduce_blockiPtPKtm_nbst = declare_device(
        '_ZL32nvshmemx_ushort_and_reduce_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_ushort_and_reduce_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_ushort_and_reduce_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_and_reduce_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_ushort_and_reduce_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_ushort_and_reduce_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_ushort_and_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint_and_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_uint_and_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint_and_reduce_blockiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_and_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uint_and_reduce_blockiPjPKjm_nbst = declare_device(
        '_ZL30nvshmemx_uint_and_reduce_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint_and_reduce_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint_and_reduce_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_and_reduce_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint_and_reduce_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint_and_reduce_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint_and_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_and_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_ulong_and_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_ulong_and_reduce_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_and_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_ulong_and_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL31nvshmemx_ulong_and_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_ulong_and_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_ulong_and_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_and_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_ulong_and_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_ulong_and_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_ulong_and_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_and_reduce_block():
    pass
    

def _lower__ZL35nvshmemx_ulonglong_and_reduce_blockiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmemx_ulonglong_and_reduce_blockiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_and_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmemx_ulonglong_and_reduce_blockiPyPKym_nbst = declare_device(
        '_ZL35nvshmemx_ulonglong_and_reduce_blockiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmemx_ulonglong_and_reduce_blockiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmemx_ulonglong_and_reduce_blockiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_and_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL35nvshmemx_ulonglong_and_reduce_blockiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmemx_ulonglong_and_reduce_blockiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmemx_ulonglong_and_reduce_blockiPyPKym_nbst(shim_stream, shim_obj)


def int8_and_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_int8_and_reduce_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int8_and_reduce_blockiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_and_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int8_and_reduce_blockiPaPKam_nbst = declare_device(
        '_ZL30nvshmemx_int8_and_reduce_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int8_and_reduce_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int8_and_reduce_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_and_reduce_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int8_and_reduce_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int8_and_reduce_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int8_and_reduce_blockiPaPKam_nbst(shim_stream, shim_obj)


def int16_and_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_int16_and_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_int16_and_reduce_blockiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_and_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_int16_and_reduce_blockiPsPKsm_nbst = declare_device(
        '_ZL31nvshmemx_int16_and_reduce_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_int16_and_reduce_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_int16_and_reduce_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_and_reduce_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_int16_and_reduce_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_int16_and_reduce_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_int16_and_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int32_and_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_int32_and_reduce_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_int32_and_reduce_blockiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_and_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_int32_and_reduce_blockiPiPKim_nbst = declare_device(
        '_ZL31nvshmemx_int32_and_reduce_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_int32_and_reduce_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_int32_and_reduce_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_and_reduce_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_int32_and_reduce_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_int32_and_reduce_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_int32_and_reduce_blockiPiPKim_nbst(shim_stream, shim_obj)


def int64_and_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_int64_and_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_int64_and_reduce_blockiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_and_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_int64_and_reduce_blockiPlPKlm_nbst = declare_device(
        '_ZL31nvshmemx_int64_and_reduce_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_int64_and_reduce_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_int64_and_reduce_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_and_reduce_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_int64_and_reduce_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_int64_and_reduce_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_int64_and_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_and_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_uint8_and_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint8_and_reduce_blockiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_and_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint8_and_reduce_blockiPhPKhm_nbst = declare_device(
        '_ZL31nvshmemx_uint8_and_reduce_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint8_and_reduce_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint8_and_reduce_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_and_reduce_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint8_and_reduce_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint8_and_reduce_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint8_and_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_and_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_uint16_and_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uint16_and_reduce_blockiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_and_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uint16_and_reduce_blockiPtPKtm_nbst = declare_device(
        '_ZL32nvshmemx_uint16_and_reduce_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uint16_and_reduce_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uint16_and_reduce_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_and_reduce_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uint16_and_reduce_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uint16_and_reduce_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uint16_and_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_and_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_uint32_and_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uint32_and_reduce_blockiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_and_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uint32_and_reduce_blockiPjPKjm_nbst = declare_device(
        '_ZL32nvshmemx_uint32_and_reduce_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uint32_and_reduce_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uint32_and_reduce_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_and_reduce_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uint32_and_reduce_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uint32_and_reduce_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uint32_and_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_and_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_uint64_and_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uint64_and_reduce_blockiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_and_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uint64_and_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL32nvshmemx_uint64_and_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uint64_and_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uint64_and_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_and_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uint64_and_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uint64_and_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uint64_and_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def size_and_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_size_and_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_size_and_reduce_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_and_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_size_and_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL30nvshmemx_size_and_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_size_and_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_size_and_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_and_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_size_and_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_size_and_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_size_and_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def uchar_or_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_uchar_or_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uchar_or_reduce_blockiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_or_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uchar_or_reduce_blockiPhPKhm_nbst = declare_device(
        '_ZL30nvshmemx_uchar_or_reduce_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uchar_or_reduce_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uchar_or_reduce_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_or_reduce_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uchar_or_reduce_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uchar_or_reduce_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uchar_or_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_or_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_ushort_or_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_ushort_or_reduce_blockiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_or_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_ushort_or_reduce_blockiPtPKtm_nbst = declare_device(
        '_ZL31nvshmemx_ushort_or_reduce_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_ushort_or_reduce_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_ushort_or_reduce_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_or_reduce_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_ushort_or_reduce_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_ushort_or_reduce_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_ushort_or_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint_or_reduce_block():
    pass
    

def _lower__ZL29nvshmemx_uint_or_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_uint_or_reduce_blockiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_or_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_uint_or_reduce_blockiPjPKjm_nbst = declare_device(
        '_ZL29nvshmemx_uint_or_reduce_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_uint_or_reduce_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_uint_or_reduce_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_or_reduce_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_uint_or_reduce_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_uint_or_reduce_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_uint_or_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_or_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_ulong_or_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_ulong_or_reduce_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_or_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_ulong_or_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL30nvshmemx_ulong_or_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_ulong_or_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_ulong_or_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_or_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_ulong_or_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_ulong_or_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_ulong_or_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_or_reduce_block():
    pass
    

def _lower__ZL34nvshmemx_ulonglong_or_reduce_blockiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmemx_ulonglong_or_reduce_blockiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_or_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmemx_ulonglong_or_reduce_blockiPyPKym_nbst = declare_device(
        '_ZL34nvshmemx_ulonglong_or_reduce_blockiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmemx_ulonglong_or_reduce_blockiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmemx_ulonglong_or_reduce_blockiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_or_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmemx_ulonglong_or_reduce_blockiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmemx_ulonglong_or_reduce_blockiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmemx_ulonglong_or_reduce_blockiPyPKym_nbst(shim_stream, shim_obj)


def int8_or_reduce_block():
    pass
    

def _lower__ZL29nvshmemx_int8_or_reduce_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int8_or_reduce_blockiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_or_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_int8_or_reduce_blockiPaPKam_nbst = declare_device(
        '_ZL29nvshmemx_int8_or_reduce_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_int8_or_reduce_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_int8_or_reduce_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_or_reduce_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int8_or_reduce_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int8_or_reduce_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_int8_or_reduce_blockiPaPKam_nbst(shim_stream, shim_obj)


def int16_or_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_int16_or_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int16_or_reduce_blockiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_or_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int16_or_reduce_blockiPsPKsm_nbst = declare_device(
        '_ZL30nvshmemx_int16_or_reduce_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int16_or_reduce_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int16_or_reduce_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_or_reduce_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int16_or_reduce_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int16_or_reduce_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int16_or_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int32_or_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_int32_or_reduce_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int32_or_reduce_blockiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_or_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int32_or_reduce_blockiPiPKim_nbst = declare_device(
        '_ZL30nvshmemx_int32_or_reduce_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int32_or_reduce_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int32_or_reduce_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_or_reduce_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int32_or_reduce_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int32_or_reduce_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int32_or_reduce_blockiPiPKim_nbst(shim_stream, shim_obj)


def int64_or_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_int64_or_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int64_or_reduce_blockiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_or_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int64_or_reduce_blockiPlPKlm_nbst = declare_device(
        '_ZL30nvshmemx_int64_or_reduce_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int64_or_reduce_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int64_or_reduce_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_or_reduce_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int64_or_reduce_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int64_or_reduce_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int64_or_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_or_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_uint8_or_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint8_or_reduce_blockiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_or_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uint8_or_reduce_blockiPhPKhm_nbst = declare_device(
        '_ZL30nvshmemx_uint8_or_reduce_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint8_or_reduce_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint8_or_reduce_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_or_reduce_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint8_or_reduce_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint8_or_reduce_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint8_or_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_or_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_uint16_or_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint16_or_reduce_blockiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_or_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint16_or_reduce_blockiPtPKtm_nbst = declare_device(
        '_ZL31nvshmemx_uint16_or_reduce_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint16_or_reduce_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint16_or_reduce_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_or_reduce_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint16_or_reduce_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint16_or_reduce_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint16_or_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_or_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_uint32_or_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint32_or_reduce_blockiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_or_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint32_or_reduce_blockiPjPKjm_nbst = declare_device(
        '_ZL31nvshmemx_uint32_or_reduce_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint32_or_reduce_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint32_or_reduce_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_or_reduce_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint32_or_reduce_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint32_or_reduce_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint32_or_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_or_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_uint64_or_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint64_or_reduce_blockiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_or_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint64_or_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL31nvshmemx_uint64_or_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint64_or_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint64_or_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_or_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint64_or_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint64_or_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint64_or_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def size_or_reduce_block():
    pass
    

def _lower__ZL29nvshmemx_size_or_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_size_or_reduce_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_or_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_size_or_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL29nvshmemx_size_or_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_size_or_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_size_or_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_or_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_size_or_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_size_or_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_size_or_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def uchar_xor_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_uchar_xor_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uchar_xor_reduce_blockiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_xor_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uchar_xor_reduce_blockiPhPKhm_nbst = declare_device(
        '_ZL31nvshmemx_uchar_xor_reduce_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uchar_xor_reduce_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uchar_xor_reduce_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_xor_reduce_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uchar_xor_reduce_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uchar_xor_reduce_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uchar_xor_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_xor_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_ushort_xor_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_ushort_xor_reduce_blockiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_xor_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_ushort_xor_reduce_blockiPtPKtm_nbst = declare_device(
        '_ZL32nvshmemx_ushort_xor_reduce_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_ushort_xor_reduce_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_ushort_xor_reduce_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_xor_reduce_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_ushort_xor_reduce_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_ushort_xor_reduce_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_ushort_xor_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint_xor_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_uint_xor_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint_xor_reduce_blockiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_xor_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uint_xor_reduce_blockiPjPKjm_nbst = declare_device(
        '_ZL30nvshmemx_uint_xor_reduce_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint_xor_reduce_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint_xor_reduce_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_xor_reduce_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint_xor_reduce_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint_xor_reduce_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint_xor_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_xor_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_ulong_xor_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_ulong_xor_reduce_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_xor_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_ulong_xor_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL31nvshmemx_ulong_xor_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_ulong_xor_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_ulong_xor_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_xor_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_ulong_xor_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_ulong_xor_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_ulong_xor_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_xor_reduce_block():
    pass
    

def _lower__ZL35nvshmemx_ulonglong_xor_reduce_blockiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmemx_ulonglong_xor_reduce_blockiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_xor_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmemx_ulonglong_xor_reduce_blockiPyPKym_nbst = declare_device(
        '_ZL35nvshmemx_ulonglong_xor_reduce_blockiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmemx_ulonglong_xor_reduce_blockiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmemx_ulonglong_xor_reduce_blockiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_xor_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL35nvshmemx_ulonglong_xor_reduce_blockiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmemx_ulonglong_xor_reduce_blockiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmemx_ulonglong_xor_reduce_blockiPyPKym_nbst(shim_stream, shim_obj)


def int8_xor_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_int8_xor_reduce_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int8_xor_reduce_blockiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_xor_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int8_xor_reduce_blockiPaPKam_nbst = declare_device(
        '_ZL30nvshmemx_int8_xor_reduce_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int8_xor_reduce_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int8_xor_reduce_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_xor_reduce_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int8_xor_reduce_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int8_xor_reduce_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int8_xor_reduce_blockiPaPKam_nbst(shim_stream, shim_obj)


def int16_xor_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_int16_xor_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_int16_xor_reduce_blockiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_xor_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_int16_xor_reduce_blockiPsPKsm_nbst = declare_device(
        '_ZL31nvshmemx_int16_xor_reduce_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_int16_xor_reduce_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_int16_xor_reduce_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_xor_reduce_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_int16_xor_reduce_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_int16_xor_reduce_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_int16_xor_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int32_xor_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_int32_xor_reduce_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_int32_xor_reduce_blockiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_xor_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_int32_xor_reduce_blockiPiPKim_nbst = declare_device(
        '_ZL31nvshmemx_int32_xor_reduce_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_int32_xor_reduce_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_int32_xor_reduce_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_xor_reduce_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_int32_xor_reduce_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_int32_xor_reduce_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_int32_xor_reduce_blockiPiPKim_nbst(shim_stream, shim_obj)


def int64_xor_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_int64_xor_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_int64_xor_reduce_blockiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_xor_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_int64_xor_reduce_blockiPlPKlm_nbst = declare_device(
        '_ZL31nvshmemx_int64_xor_reduce_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_int64_xor_reduce_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_int64_xor_reduce_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_xor_reduce_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_int64_xor_reduce_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_int64_xor_reduce_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_int64_xor_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_xor_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_uint8_xor_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint8_xor_reduce_blockiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_xor_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint8_xor_reduce_blockiPhPKhm_nbst = declare_device(
        '_ZL31nvshmemx_uint8_xor_reduce_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint8_xor_reduce_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint8_xor_reduce_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_xor_reduce_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint8_xor_reduce_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint8_xor_reduce_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint8_xor_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_xor_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_uint16_xor_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uint16_xor_reduce_blockiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_xor_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uint16_xor_reduce_blockiPtPKtm_nbst = declare_device(
        '_ZL32nvshmemx_uint16_xor_reduce_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uint16_xor_reduce_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uint16_xor_reduce_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_xor_reduce_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uint16_xor_reduce_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uint16_xor_reduce_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uint16_xor_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_xor_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_uint32_xor_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uint32_xor_reduce_blockiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_xor_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uint32_xor_reduce_blockiPjPKjm_nbst = declare_device(
        '_ZL32nvshmemx_uint32_xor_reduce_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uint32_xor_reduce_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uint32_xor_reduce_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_xor_reduce_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uint32_xor_reduce_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uint32_xor_reduce_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uint32_xor_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_xor_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_uint64_xor_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uint64_xor_reduce_blockiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_xor_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uint64_xor_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL32nvshmemx_uint64_xor_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uint64_xor_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uint64_xor_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_xor_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uint64_xor_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uint64_xor_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uint64_xor_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def size_xor_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_size_xor_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_size_xor_reduce_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_xor_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_size_xor_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL30nvshmemx_size_xor_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_size_xor_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_size_xor_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_xor_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_size_xor_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_size_xor_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_size_xor_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def uchar_max_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_uchar_max_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uchar_max_reduce_blockiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uchar_max_reduce_blockiPhPKhm_nbst = declare_device(
        '_ZL31nvshmemx_uchar_max_reduce_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uchar_max_reduce_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uchar_max_reduce_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_max_reduce_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uchar_max_reduce_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uchar_max_reduce_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uchar_max_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_max_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_ushort_max_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_ushort_max_reduce_blockiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_ushort_max_reduce_blockiPtPKtm_nbst = declare_device(
        '_ZL32nvshmemx_ushort_max_reduce_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_ushort_max_reduce_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_ushort_max_reduce_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_max_reduce_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_ushort_max_reduce_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_ushort_max_reduce_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_ushort_max_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint_max_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_uint_max_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint_max_reduce_blockiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uint_max_reduce_blockiPjPKjm_nbst = declare_device(
        '_ZL30nvshmemx_uint_max_reduce_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint_max_reduce_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint_max_reduce_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_max_reduce_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint_max_reduce_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint_max_reduce_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint_max_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_max_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_ulong_max_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_ulong_max_reduce_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_ulong_max_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL31nvshmemx_ulong_max_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_ulong_max_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_ulong_max_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_max_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_ulong_max_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_ulong_max_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_ulong_max_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_max_reduce_block():
    pass
    

def _lower__ZL35nvshmemx_ulonglong_max_reduce_blockiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmemx_ulonglong_max_reduce_blockiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmemx_ulonglong_max_reduce_blockiPyPKym_nbst = declare_device(
        '_ZL35nvshmemx_ulonglong_max_reduce_blockiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmemx_ulonglong_max_reduce_blockiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmemx_ulonglong_max_reduce_blockiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_max_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL35nvshmemx_ulonglong_max_reduce_blockiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmemx_ulonglong_max_reduce_blockiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmemx_ulonglong_max_reduce_blockiPyPKym_nbst(shim_stream, shim_obj)


def int8_max_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_int8_max_reduce_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int8_max_reduce_blockiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int8_max_reduce_blockiPaPKam_nbst = declare_device(
        '_ZL30nvshmemx_int8_max_reduce_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int8_max_reduce_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int8_max_reduce_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_max_reduce_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int8_max_reduce_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int8_max_reduce_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int8_max_reduce_blockiPaPKam_nbst(shim_stream, shim_obj)


def int16_max_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_int16_max_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_int16_max_reduce_blockiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_int16_max_reduce_blockiPsPKsm_nbst = declare_device(
        '_ZL31nvshmemx_int16_max_reduce_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_int16_max_reduce_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_int16_max_reduce_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_max_reduce_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_int16_max_reduce_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_int16_max_reduce_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_int16_max_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int32_max_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_int32_max_reduce_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_int32_max_reduce_blockiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_int32_max_reduce_blockiPiPKim_nbst = declare_device(
        '_ZL31nvshmemx_int32_max_reduce_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_int32_max_reduce_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_int32_max_reduce_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_max_reduce_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_int32_max_reduce_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_int32_max_reduce_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_int32_max_reduce_blockiPiPKim_nbst(shim_stream, shim_obj)


def int64_max_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_int64_max_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_int64_max_reduce_blockiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_int64_max_reduce_blockiPlPKlm_nbst = declare_device(
        '_ZL31nvshmemx_int64_max_reduce_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_int64_max_reduce_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_int64_max_reduce_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_max_reduce_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_int64_max_reduce_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_int64_max_reduce_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_int64_max_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_max_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_uint8_max_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint8_max_reduce_blockiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint8_max_reduce_blockiPhPKhm_nbst = declare_device(
        '_ZL31nvshmemx_uint8_max_reduce_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint8_max_reduce_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint8_max_reduce_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_max_reduce_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint8_max_reduce_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint8_max_reduce_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint8_max_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_max_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_uint16_max_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uint16_max_reduce_blockiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uint16_max_reduce_blockiPtPKtm_nbst = declare_device(
        '_ZL32nvshmemx_uint16_max_reduce_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uint16_max_reduce_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uint16_max_reduce_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_max_reduce_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uint16_max_reduce_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uint16_max_reduce_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uint16_max_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_max_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_uint32_max_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uint32_max_reduce_blockiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uint32_max_reduce_blockiPjPKjm_nbst = declare_device(
        '_ZL32nvshmemx_uint32_max_reduce_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uint32_max_reduce_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uint32_max_reduce_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_max_reduce_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uint32_max_reduce_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uint32_max_reduce_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uint32_max_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_max_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_uint64_max_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uint64_max_reduce_blockiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uint64_max_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL32nvshmemx_uint64_max_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uint64_max_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uint64_max_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_max_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uint64_max_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uint64_max_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uint64_max_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def size_max_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_size_max_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_size_max_reduce_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_size_max_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL30nvshmemx_size_max_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_size_max_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_size_max_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_max_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_size_max_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_size_max_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_size_max_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def char_max_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_char_max_reduce_blockiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_char_max_reduce_blockiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmemx_char_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_char_max_reduce_blockiPcPKcm_nbst = declare_device(
        '_ZL30nvshmemx_char_max_reduce_blockiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_char_max_reduce_blockiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_char_max_reduce_blockiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_max_reduce_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_char_max_reduce_blockiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_char_max_reduce_blockiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_char_max_reduce_blockiPcPKcm_nbst(shim_stream, shim_obj)


def schar_max_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_schar_max_reduce_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_schar_max_reduce_blockiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmemx_schar_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_schar_max_reduce_blockiPaPKam_nbst = declare_device(
        '_ZL31nvshmemx_schar_max_reduce_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_schar_max_reduce_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_schar_max_reduce_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_max_reduce_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_schar_max_reduce_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_schar_max_reduce_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_schar_max_reduce_blockiPaPKam_nbst(shim_stream, shim_obj)


def short_max_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_short_max_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_short_max_reduce_blockiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmemx_short_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_short_max_reduce_blockiPsPKsm_nbst = declare_device(
        '_ZL31nvshmemx_short_max_reduce_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_short_max_reduce_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_short_max_reduce_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_max_reduce_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_short_max_reduce_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_short_max_reduce_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_short_max_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int_max_reduce_block():
    pass
    

def _lower__ZL29nvshmemx_int_max_reduce_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int_max_reduce_blockiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmemx_int_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_int_max_reduce_blockiPiPKim_nbst = declare_device(
        '_ZL29nvshmemx_int_max_reduce_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_int_max_reduce_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_int_max_reduce_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_max_reduce_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int_max_reduce_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int_max_reduce_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_int_max_reduce_blockiPiPKim_nbst(shim_stream, shim_obj)


def long_max_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_long_max_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_long_max_reduce_blockiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmemx_long_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_long_max_reduce_blockiPlPKlm_nbst = declare_device(
        '_ZL30nvshmemx_long_max_reduce_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_long_max_reduce_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_long_max_reduce_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_max_reduce_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_long_max_reduce_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_long_max_reduce_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_long_max_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_max_reduce_block():
    pass
    

def _lower__ZL34nvshmemx_longlong_max_reduce_blockiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmemx_longlong_max_reduce_blockiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_longlong_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmemx_longlong_max_reduce_blockiPxPKxm_nbst = declare_device(
        '_ZL34nvshmemx_longlong_max_reduce_blockiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmemx_longlong_max_reduce_blockiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmemx_longlong_max_reduce_blockiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_max_reduce_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmemx_longlong_max_reduce_blockiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmemx_longlong_max_reduce_blockiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmemx_longlong_max_reduce_blockiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_max_reduce_block():
    pass
    

def _lower__ZL34nvshmemx_bfloat16_max_reduce_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmemx_bfloat16_max_reduce_blockiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmemx_bfloat16_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmemx_bfloat16_max_reduce_blockiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL34nvshmemx_bfloat16_max_reduce_blockiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmemx_bfloat16_max_reduce_blockiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmemx_bfloat16_max_reduce_blockiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_max_reduce_block, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmemx_bfloat16_max_reduce_blockiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmemx_bfloat16_max_reduce_blockiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmemx_bfloat16_max_reduce_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_max_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_half_max_reduce_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_half_max_reduce_blockiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmemx_half_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_half_max_reduce_blockiP6__halfPKS_m_nbst = declare_device(
        '_ZL30nvshmemx_half_max_reduce_blockiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_half_max_reduce_blockiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_half_max_reduce_blockiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_max_reduce_block, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_half_max_reduce_blockiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_half_max_reduce_blockiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_half_max_reduce_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_max_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_float_max_reduce_blockiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_float_max_reduce_blockiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmemx_float_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_float_max_reduce_blockiPfPKfm_nbst = declare_device(
        '_ZL31nvshmemx_float_max_reduce_blockiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_float_max_reduce_blockiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_float_max_reduce_blockiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_max_reduce_block, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_float_max_reduce_blockiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_float_max_reduce_blockiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_float_max_reduce_blockiPfPKfm_nbst(shim_stream, shim_obj)


def double_max_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_double_max_reduce_blockiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_double_max_reduce_blockiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmemx_double_max_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_double_max_reduce_blockiPdPKdm_nbst = declare_device(
        '_ZL32nvshmemx_double_max_reduce_blockiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_double_max_reduce_blockiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_double_max_reduce_blockiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_max_reduce_block, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_double_max_reduce_blockiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_double_max_reduce_blockiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_double_max_reduce_blockiPdPKdm_nbst(shim_stream, shim_obj)


def uchar_min_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_uchar_min_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uchar_min_reduce_blockiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uchar_min_reduce_blockiPhPKhm_nbst = declare_device(
        '_ZL31nvshmemx_uchar_min_reduce_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uchar_min_reduce_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uchar_min_reduce_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_min_reduce_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uchar_min_reduce_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uchar_min_reduce_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uchar_min_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_min_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_ushort_min_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_ushort_min_reduce_blockiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_ushort_min_reduce_blockiPtPKtm_nbst = declare_device(
        '_ZL32nvshmemx_ushort_min_reduce_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_ushort_min_reduce_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_ushort_min_reduce_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_min_reduce_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_ushort_min_reduce_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_ushort_min_reduce_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_ushort_min_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint_min_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_uint_min_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint_min_reduce_blockiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uint_min_reduce_blockiPjPKjm_nbst = declare_device(
        '_ZL30nvshmemx_uint_min_reduce_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint_min_reduce_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint_min_reduce_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_min_reduce_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint_min_reduce_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint_min_reduce_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint_min_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_min_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_ulong_min_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_ulong_min_reduce_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_ulong_min_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL31nvshmemx_ulong_min_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_ulong_min_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_ulong_min_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_min_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_ulong_min_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_ulong_min_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_ulong_min_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_min_reduce_block():
    pass
    

def _lower__ZL35nvshmemx_ulonglong_min_reduce_blockiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmemx_ulonglong_min_reduce_blockiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmemx_ulonglong_min_reduce_blockiPyPKym_nbst = declare_device(
        '_ZL35nvshmemx_ulonglong_min_reduce_blockiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmemx_ulonglong_min_reduce_blockiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmemx_ulonglong_min_reduce_blockiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_min_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL35nvshmemx_ulonglong_min_reduce_blockiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmemx_ulonglong_min_reduce_blockiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmemx_ulonglong_min_reduce_blockiPyPKym_nbst(shim_stream, shim_obj)


def int8_min_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_int8_min_reduce_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int8_min_reduce_blockiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int8_min_reduce_blockiPaPKam_nbst = declare_device(
        '_ZL30nvshmemx_int8_min_reduce_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int8_min_reduce_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int8_min_reduce_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_min_reduce_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int8_min_reduce_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int8_min_reduce_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int8_min_reduce_blockiPaPKam_nbst(shim_stream, shim_obj)


def int16_min_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_int16_min_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_int16_min_reduce_blockiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_int16_min_reduce_blockiPsPKsm_nbst = declare_device(
        '_ZL31nvshmemx_int16_min_reduce_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_int16_min_reduce_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_int16_min_reduce_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_min_reduce_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_int16_min_reduce_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_int16_min_reduce_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_int16_min_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int32_min_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_int32_min_reduce_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_int32_min_reduce_blockiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_int32_min_reduce_blockiPiPKim_nbst = declare_device(
        '_ZL31nvshmemx_int32_min_reduce_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_int32_min_reduce_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_int32_min_reduce_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_min_reduce_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_int32_min_reduce_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_int32_min_reduce_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_int32_min_reduce_blockiPiPKim_nbst(shim_stream, shim_obj)


def int64_min_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_int64_min_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_int64_min_reduce_blockiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_int64_min_reduce_blockiPlPKlm_nbst = declare_device(
        '_ZL31nvshmemx_int64_min_reduce_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_int64_min_reduce_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_int64_min_reduce_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_min_reduce_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_int64_min_reduce_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_int64_min_reduce_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_int64_min_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_min_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_uint8_min_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint8_min_reduce_blockiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint8_min_reduce_blockiPhPKhm_nbst = declare_device(
        '_ZL31nvshmemx_uint8_min_reduce_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint8_min_reduce_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint8_min_reduce_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_min_reduce_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint8_min_reduce_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint8_min_reduce_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint8_min_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_min_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_uint16_min_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uint16_min_reduce_blockiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uint16_min_reduce_blockiPtPKtm_nbst = declare_device(
        '_ZL32nvshmemx_uint16_min_reduce_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uint16_min_reduce_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uint16_min_reduce_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_min_reduce_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uint16_min_reduce_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uint16_min_reduce_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uint16_min_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_min_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_uint32_min_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uint32_min_reduce_blockiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uint32_min_reduce_blockiPjPKjm_nbst = declare_device(
        '_ZL32nvshmemx_uint32_min_reduce_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uint32_min_reduce_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uint32_min_reduce_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_min_reduce_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uint32_min_reduce_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uint32_min_reduce_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uint32_min_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_min_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_uint64_min_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uint64_min_reduce_blockiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uint64_min_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL32nvshmemx_uint64_min_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uint64_min_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uint64_min_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_min_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uint64_min_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uint64_min_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uint64_min_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def size_min_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_size_min_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_size_min_reduce_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_size_min_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL30nvshmemx_size_min_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_size_min_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_size_min_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_min_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_size_min_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_size_min_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_size_min_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def char_min_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_char_min_reduce_blockiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_char_min_reduce_blockiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmemx_char_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_char_min_reduce_blockiPcPKcm_nbst = declare_device(
        '_ZL30nvshmemx_char_min_reduce_blockiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_char_min_reduce_blockiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_char_min_reduce_blockiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_min_reduce_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_char_min_reduce_blockiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_char_min_reduce_blockiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_char_min_reduce_blockiPcPKcm_nbst(shim_stream, shim_obj)


def schar_min_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_schar_min_reduce_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_schar_min_reduce_blockiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmemx_schar_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_schar_min_reduce_blockiPaPKam_nbst = declare_device(
        '_ZL31nvshmemx_schar_min_reduce_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_schar_min_reduce_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_schar_min_reduce_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_min_reduce_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_schar_min_reduce_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_schar_min_reduce_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_schar_min_reduce_blockiPaPKam_nbst(shim_stream, shim_obj)


def short_min_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_short_min_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_short_min_reduce_blockiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmemx_short_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_short_min_reduce_blockiPsPKsm_nbst = declare_device(
        '_ZL31nvshmemx_short_min_reduce_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_short_min_reduce_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_short_min_reduce_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_min_reduce_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_short_min_reduce_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_short_min_reduce_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_short_min_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int_min_reduce_block():
    pass
    

def _lower__ZL29nvshmemx_int_min_reduce_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int_min_reduce_blockiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmemx_int_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_int_min_reduce_blockiPiPKim_nbst = declare_device(
        '_ZL29nvshmemx_int_min_reduce_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_int_min_reduce_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_int_min_reduce_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_min_reduce_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int_min_reduce_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int_min_reduce_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_int_min_reduce_blockiPiPKim_nbst(shim_stream, shim_obj)


def long_min_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_long_min_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_long_min_reduce_blockiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmemx_long_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_long_min_reduce_blockiPlPKlm_nbst = declare_device(
        '_ZL30nvshmemx_long_min_reduce_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_long_min_reduce_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_long_min_reduce_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_min_reduce_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_long_min_reduce_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_long_min_reduce_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_long_min_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_min_reduce_block():
    pass
    

def _lower__ZL34nvshmemx_longlong_min_reduce_blockiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmemx_longlong_min_reduce_blockiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_longlong_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmemx_longlong_min_reduce_blockiPxPKxm_nbst = declare_device(
        '_ZL34nvshmemx_longlong_min_reduce_blockiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmemx_longlong_min_reduce_blockiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmemx_longlong_min_reduce_blockiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_min_reduce_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmemx_longlong_min_reduce_blockiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmemx_longlong_min_reduce_blockiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmemx_longlong_min_reduce_blockiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_min_reduce_block():
    pass
    

def _lower__ZL34nvshmemx_bfloat16_min_reduce_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmemx_bfloat16_min_reduce_blockiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmemx_bfloat16_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmemx_bfloat16_min_reduce_blockiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL34nvshmemx_bfloat16_min_reduce_blockiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmemx_bfloat16_min_reduce_blockiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmemx_bfloat16_min_reduce_blockiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_min_reduce_block, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmemx_bfloat16_min_reduce_blockiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmemx_bfloat16_min_reduce_blockiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmemx_bfloat16_min_reduce_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_min_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_half_min_reduce_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_half_min_reduce_blockiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmemx_half_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_half_min_reduce_blockiP6__halfPKS_m_nbst = declare_device(
        '_ZL30nvshmemx_half_min_reduce_blockiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_half_min_reduce_blockiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_half_min_reduce_blockiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_min_reduce_block, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_half_min_reduce_blockiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_half_min_reduce_blockiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_half_min_reduce_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_min_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_float_min_reduce_blockiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_float_min_reduce_blockiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmemx_float_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_float_min_reduce_blockiPfPKfm_nbst = declare_device(
        '_ZL31nvshmemx_float_min_reduce_blockiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_float_min_reduce_blockiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_float_min_reduce_blockiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_min_reduce_block, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_float_min_reduce_blockiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_float_min_reduce_blockiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_float_min_reduce_blockiPfPKfm_nbst(shim_stream, shim_obj)


def double_min_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_double_min_reduce_blockiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_double_min_reduce_blockiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmemx_double_min_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_double_min_reduce_blockiPdPKdm_nbst = declare_device(
        '_ZL32nvshmemx_double_min_reduce_blockiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_double_min_reduce_blockiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_double_min_reduce_blockiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_min_reduce_block, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_double_min_reduce_blockiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_double_min_reduce_blockiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_double_min_reduce_blockiPdPKdm_nbst(shim_stream, shim_obj)


def uchar_sum_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_uchar_sum_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uchar_sum_reduce_blockiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uchar_sum_reduce_blockiPhPKhm_nbst = declare_device(
        '_ZL31nvshmemx_uchar_sum_reduce_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uchar_sum_reduce_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uchar_sum_reduce_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_sum_reduce_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uchar_sum_reduce_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uchar_sum_reduce_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uchar_sum_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_sum_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_ushort_sum_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_ushort_sum_reduce_blockiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_ushort_sum_reduce_blockiPtPKtm_nbst = declare_device(
        '_ZL32nvshmemx_ushort_sum_reduce_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_ushort_sum_reduce_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_ushort_sum_reduce_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_sum_reduce_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_ushort_sum_reduce_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_ushort_sum_reduce_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_ushort_sum_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint_sum_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_uint_sum_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_uint_sum_reduce_blockiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_uint_sum_reduce_blockiPjPKjm_nbst = declare_device(
        '_ZL30nvshmemx_uint_sum_reduce_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_uint_sum_reduce_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_uint_sum_reduce_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_sum_reduce_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_uint_sum_reduce_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_uint_sum_reduce_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_uint_sum_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_sum_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_ulong_sum_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_ulong_sum_reduce_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_ulong_sum_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL31nvshmemx_ulong_sum_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_ulong_sum_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_ulong_sum_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_sum_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_ulong_sum_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_ulong_sum_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_ulong_sum_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_sum_reduce_block():
    pass
    

def _lower__ZL35nvshmemx_ulonglong_sum_reduce_blockiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmemx_ulonglong_sum_reduce_blockiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmemx_ulonglong_sum_reduce_blockiPyPKym_nbst = declare_device(
        '_ZL35nvshmemx_ulonglong_sum_reduce_blockiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmemx_ulonglong_sum_reduce_blockiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmemx_ulonglong_sum_reduce_blockiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_sum_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL35nvshmemx_ulonglong_sum_reduce_blockiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmemx_ulonglong_sum_reduce_blockiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmemx_ulonglong_sum_reduce_blockiPyPKym_nbst(shim_stream, shim_obj)


def int8_sum_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_int8_sum_reduce_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int8_sum_reduce_blockiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int8_sum_reduce_blockiPaPKam_nbst = declare_device(
        '_ZL30nvshmemx_int8_sum_reduce_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int8_sum_reduce_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int8_sum_reduce_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_sum_reduce_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int8_sum_reduce_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int8_sum_reduce_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int8_sum_reduce_blockiPaPKam_nbst(shim_stream, shim_obj)


def int16_sum_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_int16_sum_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_int16_sum_reduce_blockiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_int16_sum_reduce_blockiPsPKsm_nbst = declare_device(
        '_ZL31nvshmemx_int16_sum_reduce_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_int16_sum_reduce_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_int16_sum_reduce_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_sum_reduce_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_int16_sum_reduce_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_int16_sum_reduce_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_int16_sum_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int32_sum_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_int32_sum_reduce_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_int32_sum_reduce_blockiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_int32_sum_reduce_blockiPiPKim_nbst = declare_device(
        '_ZL31nvshmemx_int32_sum_reduce_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_int32_sum_reduce_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_int32_sum_reduce_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_sum_reduce_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_int32_sum_reduce_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_int32_sum_reduce_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_int32_sum_reduce_blockiPiPKim_nbst(shim_stream, shim_obj)


def int64_sum_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_int64_sum_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_int64_sum_reduce_blockiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_int64_sum_reduce_blockiPlPKlm_nbst = declare_device(
        '_ZL31nvshmemx_int64_sum_reduce_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_int64_sum_reduce_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_int64_sum_reduce_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_sum_reduce_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_int64_sum_reduce_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_int64_sum_reduce_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_int64_sum_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_sum_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_uint8_sum_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint8_sum_reduce_blockiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint8_sum_reduce_blockiPhPKhm_nbst = declare_device(
        '_ZL31nvshmemx_uint8_sum_reduce_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint8_sum_reduce_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint8_sum_reduce_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_sum_reduce_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint8_sum_reduce_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint8_sum_reduce_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint8_sum_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_sum_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_uint16_sum_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uint16_sum_reduce_blockiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uint16_sum_reduce_blockiPtPKtm_nbst = declare_device(
        '_ZL32nvshmemx_uint16_sum_reduce_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uint16_sum_reduce_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uint16_sum_reduce_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_sum_reduce_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uint16_sum_reduce_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uint16_sum_reduce_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uint16_sum_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_sum_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_uint32_sum_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uint32_sum_reduce_blockiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uint32_sum_reduce_blockiPjPKjm_nbst = declare_device(
        '_ZL32nvshmemx_uint32_sum_reduce_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uint32_sum_reduce_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uint32_sum_reduce_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_sum_reduce_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uint32_sum_reduce_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uint32_sum_reduce_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uint32_sum_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_sum_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_uint64_sum_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uint64_sum_reduce_blockiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uint64_sum_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL32nvshmemx_uint64_sum_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uint64_sum_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uint64_sum_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_sum_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uint64_sum_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uint64_sum_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uint64_sum_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def size_sum_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_size_sum_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_size_sum_reduce_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_size_sum_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL30nvshmemx_size_sum_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_size_sum_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_size_sum_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_sum_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_size_sum_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_size_sum_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_size_sum_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def char_sum_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_char_sum_reduce_blockiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_char_sum_reduce_blockiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmemx_char_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_char_sum_reduce_blockiPcPKcm_nbst = declare_device(
        '_ZL30nvshmemx_char_sum_reduce_blockiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_char_sum_reduce_blockiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_char_sum_reduce_blockiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_sum_reduce_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_char_sum_reduce_blockiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_char_sum_reduce_blockiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_char_sum_reduce_blockiPcPKcm_nbst(shim_stream, shim_obj)


def schar_sum_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_schar_sum_reduce_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_schar_sum_reduce_blockiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmemx_schar_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_schar_sum_reduce_blockiPaPKam_nbst = declare_device(
        '_ZL31nvshmemx_schar_sum_reduce_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_schar_sum_reduce_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_schar_sum_reduce_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_sum_reduce_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_schar_sum_reduce_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_schar_sum_reduce_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_schar_sum_reduce_blockiPaPKam_nbst(shim_stream, shim_obj)


def short_sum_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_short_sum_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_short_sum_reduce_blockiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmemx_short_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_short_sum_reduce_blockiPsPKsm_nbst = declare_device(
        '_ZL31nvshmemx_short_sum_reduce_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_short_sum_reduce_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_short_sum_reduce_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_sum_reduce_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_short_sum_reduce_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_short_sum_reduce_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_short_sum_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int_sum_reduce_block():
    pass
    

def _lower__ZL29nvshmemx_int_sum_reduce_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL29nvshmemx_int_sum_reduce_blockiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmemx_int_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL29nvshmemx_int_sum_reduce_blockiPiPKim_nbst = declare_device(
        '_ZL29nvshmemx_int_sum_reduce_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL29nvshmemx_int_sum_reduce_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL29nvshmemx_int_sum_reduce_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_sum_reduce_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL29nvshmemx_int_sum_reduce_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL29nvshmemx_int_sum_reduce_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL29nvshmemx_int_sum_reduce_blockiPiPKim_nbst(shim_stream, shim_obj)


def long_sum_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_long_sum_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_long_sum_reduce_blockiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmemx_long_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_long_sum_reduce_blockiPlPKlm_nbst = declare_device(
        '_ZL30nvshmemx_long_sum_reduce_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_long_sum_reduce_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_long_sum_reduce_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_sum_reduce_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_long_sum_reduce_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_long_sum_reduce_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_long_sum_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_sum_reduce_block():
    pass
    

def _lower__ZL34nvshmemx_longlong_sum_reduce_blockiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmemx_longlong_sum_reduce_blockiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_longlong_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmemx_longlong_sum_reduce_blockiPxPKxm_nbst = declare_device(
        '_ZL34nvshmemx_longlong_sum_reduce_blockiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmemx_longlong_sum_reduce_blockiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmemx_longlong_sum_reduce_blockiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_sum_reduce_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmemx_longlong_sum_reduce_blockiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmemx_longlong_sum_reduce_blockiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmemx_longlong_sum_reduce_blockiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_sum_reduce_block():
    pass
    

def _lower__ZL34nvshmemx_bfloat16_sum_reduce_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL34nvshmemx_bfloat16_sum_reduce_blockiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmemx_bfloat16_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL34nvshmemx_bfloat16_sum_reduce_blockiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL34nvshmemx_bfloat16_sum_reduce_blockiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL34nvshmemx_bfloat16_sum_reduce_blockiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL34nvshmemx_bfloat16_sum_reduce_blockiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_sum_reduce_block, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL34nvshmemx_bfloat16_sum_reduce_blockiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL34nvshmemx_bfloat16_sum_reduce_blockiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL34nvshmemx_bfloat16_sum_reduce_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_sum_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_half_sum_reduce_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_half_sum_reduce_blockiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmemx_half_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_half_sum_reduce_blockiP6__halfPKS_m_nbst = declare_device(
        '_ZL30nvshmemx_half_sum_reduce_blockiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_half_sum_reduce_blockiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_half_sum_reduce_blockiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_sum_reduce_block, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_half_sum_reduce_blockiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_half_sum_reduce_blockiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_half_sum_reduce_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_sum_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_float_sum_reduce_blockiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_float_sum_reduce_blockiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmemx_float_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_float_sum_reduce_blockiPfPKfm_nbst = declare_device(
        '_ZL31nvshmemx_float_sum_reduce_blockiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_float_sum_reduce_blockiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_float_sum_reduce_blockiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_sum_reduce_block, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_float_sum_reduce_blockiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_float_sum_reduce_blockiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_float_sum_reduce_blockiPfPKfm_nbst(shim_stream, shim_obj)


def double_sum_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_double_sum_reduce_blockiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_double_sum_reduce_blockiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmemx_double_sum_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_double_sum_reduce_blockiPdPKdm_nbst = declare_device(
        '_ZL32nvshmemx_double_sum_reduce_blockiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_double_sum_reduce_blockiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_double_sum_reduce_blockiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_sum_reduce_block, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_double_sum_reduce_blockiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_double_sum_reduce_blockiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_double_sum_reduce_blockiPdPKdm_nbst(shim_stream, shim_obj)


def uchar_prod_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_uchar_prod_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uchar_prod_reduce_blockiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uchar_prod_reduce_blockiPhPKhm_nbst = declare_device(
        '_ZL32nvshmemx_uchar_prod_reduce_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uchar_prod_reduce_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uchar_prod_reduce_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_prod_reduce_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uchar_prod_reduce_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uchar_prod_reduce_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uchar_prod_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_prod_reduce_block():
    pass
    

def _lower__ZL33nvshmemx_ushort_prod_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmemx_ushort_prod_reduce_blockiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL33nvshmemx_ushort_prod_reduce_blockiPtPKtm_nbst = declare_device(
        '_ZL33nvshmemx_ushort_prod_reduce_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL33nvshmemx_ushort_prod_reduce_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL33nvshmemx_ushort_prod_reduce_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_prod_reduce_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmemx_ushort_prod_reduce_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmemx_ushort_prod_reduce_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL33nvshmemx_ushort_prod_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint_prod_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_uint_prod_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_uint_prod_reduce_blockiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_uint_prod_reduce_blockiPjPKjm_nbst = declare_device(
        '_ZL31nvshmemx_uint_prod_reduce_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_uint_prod_reduce_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_uint_prod_reduce_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_prod_reduce_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_uint_prod_reduce_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_uint_prod_reduce_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_uint_prod_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_prod_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_ulong_prod_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_ulong_prod_reduce_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_ulong_prod_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL32nvshmemx_ulong_prod_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_ulong_prod_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_ulong_prod_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_prod_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_ulong_prod_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_ulong_prod_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_ulong_prod_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_prod_reduce_block():
    pass
    

def _lower__ZL36nvshmemx_ulonglong_prod_reduce_blockiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_ulonglong_prod_reduce_blockiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_ulonglong_prod_reduce_blockiPyPKym_nbst = declare_device(
        '_ZL36nvshmemx_ulonglong_prod_reduce_blockiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_ulonglong_prod_reduce_blockiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_ulonglong_prod_reduce_blockiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_prod_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL36nvshmemx_ulonglong_prod_reduce_blockiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_ulonglong_prod_reduce_blockiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_ulonglong_prod_reduce_blockiPyPKym_nbst(shim_stream, shim_obj)


def int8_prod_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_int8_prod_reduce_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_int8_prod_reduce_blockiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_int8_prod_reduce_blockiPaPKam_nbst = declare_device(
        '_ZL31nvshmemx_int8_prod_reduce_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_int8_prod_reduce_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_int8_prod_reduce_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_prod_reduce_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_int8_prod_reduce_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_int8_prod_reduce_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_int8_prod_reduce_blockiPaPKam_nbst(shim_stream, shim_obj)


def int16_prod_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_int16_prod_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_int16_prod_reduce_blockiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_int16_prod_reduce_blockiPsPKsm_nbst = declare_device(
        '_ZL32nvshmemx_int16_prod_reduce_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_int16_prod_reduce_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_int16_prod_reduce_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_prod_reduce_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_int16_prod_reduce_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_int16_prod_reduce_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_int16_prod_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int32_prod_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_int32_prod_reduce_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_int32_prod_reduce_blockiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_int32_prod_reduce_blockiPiPKim_nbst = declare_device(
        '_ZL32nvshmemx_int32_prod_reduce_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_int32_prod_reduce_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_int32_prod_reduce_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_prod_reduce_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_int32_prod_reduce_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_int32_prod_reduce_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_int32_prod_reduce_blockiPiPKim_nbst(shim_stream, shim_obj)


def int64_prod_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_int64_prod_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_int64_prod_reduce_blockiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_int64_prod_reduce_blockiPlPKlm_nbst = declare_device(
        '_ZL32nvshmemx_int64_prod_reduce_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_int64_prod_reduce_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_int64_prod_reduce_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_prod_reduce_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_int64_prod_reduce_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_int64_prod_reduce_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_int64_prod_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_prod_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_uint8_prod_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_uint8_prod_reduce_blockiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_uint8_prod_reduce_blockiPhPKhm_nbst = declare_device(
        '_ZL32nvshmemx_uint8_prod_reduce_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_uint8_prod_reduce_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_uint8_prod_reduce_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_prod_reduce_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_uint8_prod_reduce_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_uint8_prod_reduce_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_uint8_prod_reduce_blockiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_prod_reduce_block():
    pass
    

def _lower__ZL33nvshmemx_uint16_prod_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmemx_uint16_prod_reduce_blockiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL33nvshmemx_uint16_prod_reduce_blockiPtPKtm_nbst = declare_device(
        '_ZL33nvshmemx_uint16_prod_reduce_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL33nvshmemx_uint16_prod_reduce_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL33nvshmemx_uint16_prod_reduce_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_prod_reduce_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmemx_uint16_prod_reduce_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmemx_uint16_prod_reduce_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL33nvshmemx_uint16_prod_reduce_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_prod_reduce_block():
    pass
    

def _lower__ZL33nvshmemx_uint32_prod_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmemx_uint32_prod_reduce_blockiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL33nvshmemx_uint32_prod_reduce_blockiPjPKjm_nbst = declare_device(
        '_ZL33nvshmemx_uint32_prod_reduce_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL33nvshmemx_uint32_prod_reduce_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL33nvshmemx_uint32_prod_reduce_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_prod_reduce_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmemx_uint32_prod_reduce_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmemx_uint32_prod_reduce_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL33nvshmemx_uint32_prod_reduce_blockiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_prod_reduce_block():
    pass
    

def _lower__ZL33nvshmemx_uint64_prod_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmemx_uint64_prod_reduce_blockiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL33nvshmemx_uint64_prod_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL33nvshmemx_uint64_prod_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL33nvshmemx_uint64_prod_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL33nvshmemx_uint64_prod_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_prod_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmemx_uint64_prod_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmemx_uint64_prod_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL33nvshmemx_uint64_prod_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def size_prod_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_size_prod_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_size_prod_reduce_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_size_prod_reduce_blockiPmPKmm_nbst = declare_device(
        '_ZL31nvshmemx_size_prod_reduce_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_size_prod_reduce_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_size_prod_reduce_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_prod_reduce_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_size_prod_reduce_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_size_prod_reduce_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_size_prod_reduce_blockiPmPKmm_nbst(shim_stream, shim_obj)


def char_prod_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_char_prod_reduce_blockiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_char_prod_reduce_blockiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmemx_char_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_char_prod_reduce_blockiPcPKcm_nbst = declare_device(
        '_ZL31nvshmemx_char_prod_reduce_blockiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_char_prod_reduce_blockiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_char_prod_reduce_blockiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_prod_reduce_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_char_prod_reduce_blockiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_char_prod_reduce_blockiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_char_prod_reduce_blockiPcPKcm_nbst(shim_stream, shim_obj)


def schar_prod_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_schar_prod_reduce_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_schar_prod_reduce_blockiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmemx_schar_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_schar_prod_reduce_blockiPaPKam_nbst = declare_device(
        '_ZL32nvshmemx_schar_prod_reduce_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_schar_prod_reduce_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_schar_prod_reduce_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_prod_reduce_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_schar_prod_reduce_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_schar_prod_reduce_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_schar_prod_reduce_blockiPaPKam_nbst(shim_stream, shim_obj)


def short_prod_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_short_prod_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_short_prod_reduce_blockiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmemx_short_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_short_prod_reduce_blockiPsPKsm_nbst = declare_device(
        '_ZL32nvshmemx_short_prod_reduce_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_short_prod_reduce_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_short_prod_reduce_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_prod_reduce_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_short_prod_reduce_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_short_prod_reduce_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_short_prod_reduce_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int_prod_reduce_block():
    pass
    

def _lower__ZL30nvshmemx_int_prod_reduce_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL30nvshmemx_int_prod_reduce_blockiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmemx_int_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL30nvshmemx_int_prod_reduce_blockiPiPKim_nbst = declare_device(
        '_ZL30nvshmemx_int_prod_reduce_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL30nvshmemx_int_prod_reduce_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL30nvshmemx_int_prod_reduce_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_prod_reduce_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL30nvshmemx_int_prod_reduce_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL30nvshmemx_int_prod_reduce_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL30nvshmemx_int_prod_reduce_blockiPiPKim_nbst(shim_stream, shim_obj)


def long_prod_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_long_prod_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_long_prod_reduce_blockiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmemx_long_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_long_prod_reduce_blockiPlPKlm_nbst = declare_device(
        '_ZL31nvshmemx_long_prod_reduce_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_long_prod_reduce_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_long_prod_reduce_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_prod_reduce_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_long_prod_reduce_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_long_prod_reduce_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_long_prod_reduce_blockiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_prod_reduce_block():
    pass
    

def _lower__ZL35nvshmemx_longlong_prod_reduce_blockiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmemx_longlong_prod_reduce_blockiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_longlong_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmemx_longlong_prod_reduce_blockiPxPKxm_nbst = declare_device(
        '_ZL35nvshmemx_longlong_prod_reduce_blockiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmemx_longlong_prod_reduce_blockiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmemx_longlong_prod_reduce_blockiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_prod_reduce_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL35nvshmemx_longlong_prod_reduce_blockiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmemx_longlong_prod_reduce_blockiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmemx_longlong_prod_reduce_blockiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_prod_reduce_block():
    pass
    

def _lower__ZL35nvshmemx_bfloat16_prod_reduce_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmemx_bfloat16_prod_reduce_blockiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmemx_bfloat16_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmemx_bfloat16_prod_reduce_blockiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL35nvshmemx_bfloat16_prod_reduce_blockiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmemx_bfloat16_prod_reduce_blockiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmemx_bfloat16_prod_reduce_blockiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_prod_reduce_block, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL35nvshmemx_bfloat16_prod_reduce_blockiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmemx_bfloat16_prod_reduce_blockiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmemx_bfloat16_prod_reduce_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_prod_reduce_block():
    pass
    

def _lower__ZL31nvshmemx_half_prod_reduce_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL31nvshmemx_half_prod_reduce_blockiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmemx_half_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL31nvshmemx_half_prod_reduce_blockiP6__halfPKS_m_nbst = declare_device(
        '_ZL31nvshmemx_half_prod_reduce_blockiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL31nvshmemx_half_prod_reduce_blockiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL31nvshmemx_half_prod_reduce_blockiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_prod_reduce_block, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL31nvshmemx_half_prod_reduce_blockiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL31nvshmemx_half_prod_reduce_blockiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL31nvshmemx_half_prod_reduce_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_prod_reduce_block():
    pass
    

def _lower__ZL32nvshmemx_float_prod_reduce_blockiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL32nvshmemx_float_prod_reduce_blockiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmemx_float_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL32nvshmemx_float_prod_reduce_blockiPfPKfm_nbst = declare_device(
        '_ZL32nvshmemx_float_prod_reduce_blockiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL32nvshmemx_float_prod_reduce_blockiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL32nvshmemx_float_prod_reduce_blockiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_prod_reduce_block, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL32nvshmemx_float_prod_reduce_blockiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL32nvshmemx_float_prod_reduce_blockiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL32nvshmemx_float_prod_reduce_blockiPfPKfm_nbst(shim_stream, shim_obj)


def double_prod_reduce_block():
    pass
    

def _lower__ZL33nvshmemx_double_prod_reduce_blockiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL33nvshmemx_double_prod_reduce_blockiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmemx_double_prod_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL33nvshmemx_double_prod_reduce_blockiPdPKdm_nbst = declare_device(
        '_ZL33nvshmemx_double_prod_reduce_blockiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL33nvshmemx_double_prod_reduce_blockiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL33nvshmemx_double_prod_reduce_blockiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_prod_reduce_block, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        context.active_code_library.use_cooperative = True

        shim_stream.write_with_key("_ZL33nvshmemx_double_prod_reduce_blockiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL33nvshmemx_double_prod_reduce_blockiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL33nvshmemx_double_prod_reduce_blockiPdPKdm_nbst(shim_stream, shim_obj)


def uchar_and_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_uchar_and_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uchar_and_reducescatter_warpiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_and_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uchar_and_reducescatter_warpiPhPKhm_nbst = declare_device(
        '_ZL37nvshmemx_uchar_and_reducescatter_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uchar_and_reducescatter_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uchar_and_reducescatter_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_and_reducescatter_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uchar_and_reducescatter_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uchar_and_reducescatter_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uchar_and_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_and_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_ushort_and_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_ushort_and_reducescatter_warpiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_and_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_ushort_and_reducescatter_warpiPtPKtm_nbst = declare_device(
        '_ZL38nvshmemx_ushort_and_reducescatter_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_ushort_and_reducescatter_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_ushort_and_reducescatter_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_and_reducescatter_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_ushort_and_reducescatter_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_ushort_and_reducescatter_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_ushort_and_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint_and_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_uint_and_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_uint_and_reducescatter_warpiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_and_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_uint_and_reducescatter_warpiPjPKjm_nbst = declare_device(
        '_ZL36nvshmemx_uint_and_reducescatter_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_uint_and_reducescatter_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_uint_and_reducescatter_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_and_reducescatter_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_uint_and_reducescatter_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_uint_and_reducescatter_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_uint_and_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_and_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_ulong_and_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_ulong_and_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_and_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_ulong_and_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL37nvshmemx_ulong_and_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_ulong_and_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_ulong_and_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_and_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_ulong_and_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_ulong_and_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_ulong_and_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_and_reducescatter_warp():
    pass
    

def _lower__ZL41nvshmemx_ulonglong_and_reducescatter_warpiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL41nvshmemx_ulonglong_and_reducescatter_warpiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_and_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL41nvshmemx_ulonglong_and_reducescatter_warpiPyPKym_nbst = declare_device(
        '_ZL41nvshmemx_ulonglong_and_reducescatter_warpiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL41nvshmemx_ulonglong_and_reducescatter_warpiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL41nvshmemx_ulonglong_and_reducescatter_warpiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_and_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL41nvshmemx_ulonglong_and_reducescatter_warpiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL41nvshmemx_ulonglong_and_reducescatter_warpiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL41nvshmemx_ulonglong_and_reducescatter_warpiPyPKym_nbst(shim_stream, shim_obj)


def int8_and_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_int8_and_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_int8_and_reducescatter_warpiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_and_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_int8_and_reducescatter_warpiPaPKam_nbst = declare_device(
        '_ZL36nvshmemx_int8_and_reducescatter_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_int8_and_reducescatter_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_int8_and_reducescatter_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_and_reducescatter_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_int8_and_reducescatter_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_int8_and_reducescatter_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_int8_and_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj)


def int16_and_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_int16_and_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int16_and_reducescatter_warpiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_and_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int16_and_reducescatter_warpiPsPKsm_nbst = declare_device(
        '_ZL37nvshmemx_int16_and_reducescatter_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int16_and_reducescatter_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int16_and_reducescatter_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_and_reducescatter_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int16_and_reducescatter_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int16_and_reducescatter_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int16_and_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int32_and_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_int32_and_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int32_and_reducescatter_warpiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_and_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int32_and_reducescatter_warpiPiPKim_nbst = declare_device(
        '_ZL37nvshmemx_int32_and_reducescatter_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int32_and_reducescatter_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int32_and_reducescatter_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_and_reducescatter_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int32_and_reducescatter_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int32_and_reducescatter_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int32_and_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj)


def int64_and_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_int64_and_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int64_and_reducescatter_warpiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_and_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int64_and_reducescatter_warpiPlPKlm_nbst = declare_device(
        '_ZL37nvshmemx_int64_and_reducescatter_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int64_and_reducescatter_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int64_and_reducescatter_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_and_reducescatter_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int64_and_reducescatter_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int64_and_reducescatter_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int64_and_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_and_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_uint8_and_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uint8_and_reducescatter_warpiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_and_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uint8_and_reducescatter_warpiPhPKhm_nbst = declare_device(
        '_ZL37nvshmemx_uint8_and_reducescatter_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uint8_and_reducescatter_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uint8_and_reducescatter_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_and_reducescatter_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uint8_and_reducescatter_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uint8_and_reducescatter_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uint8_and_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_and_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_uint16_and_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint16_and_reducescatter_warpiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_and_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint16_and_reducescatter_warpiPtPKtm_nbst = declare_device(
        '_ZL38nvshmemx_uint16_and_reducescatter_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint16_and_reducescatter_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint16_and_reducescatter_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_and_reducescatter_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint16_and_reducescatter_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint16_and_reducescatter_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint16_and_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_and_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_uint32_and_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint32_and_reducescatter_warpiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_and_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint32_and_reducescatter_warpiPjPKjm_nbst = declare_device(
        '_ZL38nvshmemx_uint32_and_reducescatter_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint32_and_reducescatter_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint32_and_reducescatter_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_and_reducescatter_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint32_and_reducescatter_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint32_and_reducescatter_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint32_and_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_and_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_uint64_and_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint64_and_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_and_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint64_and_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL38nvshmemx_uint64_and_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint64_and_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint64_and_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_and_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint64_and_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint64_and_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint64_and_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def size_and_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_size_and_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_size_and_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_and_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_size_and_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL36nvshmemx_size_and_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_size_and_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_size_and_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_and_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_size_and_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_size_and_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_size_and_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def uchar_or_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_uchar_or_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_uchar_or_reducescatter_warpiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_or_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_uchar_or_reducescatter_warpiPhPKhm_nbst = declare_device(
        '_ZL36nvshmemx_uchar_or_reducescatter_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_uchar_or_reducescatter_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_uchar_or_reducescatter_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_or_reducescatter_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_uchar_or_reducescatter_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_uchar_or_reducescatter_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_uchar_or_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_or_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_ushort_or_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_ushort_or_reducescatter_warpiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_or_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_ushort_or_reducescatter_warpiPtPKtm_nbst = declare_device(
        '_ZL37nvshmemx_ushort_or_reducescatter_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_ushort_or_reducescatter_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_ushort_or_reducescatter_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_or_reducescatter_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_ushort_or_reducescatter_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_ushort_or_reducescatter_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_ushort_or_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint_or_reducescatter_warp():
    pass
    

def _lower__ZL35nvshmemx_uint_or_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmemx_uint_or_reducescatter_warpiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_or_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmemx_uint_or_reducescatter_warpiPjPKjm_nbst = declare_device(
        '_ZL35nvshmemx_uint_or_reducescatter_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmemx_uint_or_reducescatter_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmemx_uint_or_reducescatter_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_or_reducescatter_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL35nvshmemx_uint_or_reducescatter_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmemx_uint_or_reducescatter_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmemx_uint_or_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_or_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_ulong_or_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_ulong_or_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_or_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_ulong_or_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL36nvshmemx_ulong_or_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_ulong_or_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_ulong_or_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_or_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_ulong_or_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_ulong_or_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_ulong_or_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_or_reducescatter_warp():
    pass
    

def _lower__ZL40nvshmemx_ulonglong_or_reducescatter_warpiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL40nvshmemx_ulonglong_or_reducescatter_warpiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_or_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL40nvshmemx_ulonglong_or_reducescatter_warpiPyPKym_nbst = declare_device(
        '_ZL40nvshmemx_ulonglong_or_reducescatter_warpiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL40nvshmemx_ulonglong_or_reducescatter_warpiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL40nvshmemx_ulonglong_or_reducescatter_warpiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_or_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL40nvshmemx_ulonglong_or_reducescatter_warpiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL40nvshmemx_ulonglong_or_reducescatter_warpiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL40nvshmemx_ulonglong_or_reducescatter_warpiPyPKym_nbst(shim_stream, shim_obj)


def int8_or_reducescatter_warp():
    pass
    

def _lower__ZL35nvshmemx_int8_or_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmemx_int8_or_reducescatter_warpiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_or_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmemx_int8_or_reducescatter_warpiPaPKam_nbst = declare_device(
        '_ZL35nvshmemx_int8_or_reducescatter_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmemx_int8_or_reducescatter_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmemx_int8_or_reducescatter_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_or_reducescatter_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL35nvshmemx_int8_or_reducescatter_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmemx_int8_or_reducescatter_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmemx_int8_or_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj)


def int16_or_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_int16_or_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_int16_or_reducescatter_warpiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_or_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_int16_or_reducescatter_warpiPsPKsm_nbst = declare_device(
        '_ZL36nvshmemx_int16_or_reducescatter_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_int16_or_reducescatter_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_int16_or_reducescatter_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_or_reducescatter_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_int16_or_reducescatter_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_int16_or_reducescatter_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_int16_or_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int32_or_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_int32_or_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_int32_or_reducescatter_warpiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_or_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_int32_or_reducescatter_warpiPiPKim_nbst = declare_device(
        '_ZL36nvshmemx_int32_or_reducescatter_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_int32_or_reducescatter_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_int32_or_reducescatter_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_or_reducescatter_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_int32_or_reducescatter_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_int32_or_reducescatter_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_int32_or_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj)


def int64_or_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_int64_or_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_int64_or_reducescatter_warpiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_or_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_int64_or_reducescatter_warpiPlPKlm_nbst = declare_device(
        '_ZL36nvshmemx_int64_or_reducescatter_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_int64_or_reducescatter_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_int64_or_reducescatter_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_or_reducescatter_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_int64_or_reducescatter_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_int64_or_reducescatter_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_int64_or_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_or_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_uint8_or_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_uint8_or_reducescatter_warpiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_or_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_uint8_or_reducescatter_warpiPhPKhm_nbst = declare_device(
        '_ZL36nvshmemx_uint8_or_reducescatter_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_uint8_or_reducescatter_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_uint8_or_reducescatter_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_or_reducescatter_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_uint8_or_reducescatter_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_uint8_or_reducescatter_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_uint8_or_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_or_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_uint16_or_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uint16_or_reducescatter_warpiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_or_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uint16_or_reducescatter_warpiPtPKtm_nbst = declare_device(
        '_ZL37nvshmemx_uint16_or_reducescatter_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uint16_or_reducescatter_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uint16_or_reducescatter_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_or_reducescatter_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uint16_or_reducescatter_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uint16_or_reducescatter_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uint16_or_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_or_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_uint32_or_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uint32_or_reducescatter_warpiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_or_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uint32_or_reducescatter_warpiPjPKjm_nbst = declare_device(
        '_ZL37nvshmemx_uint32_or_reducescatter_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uint32_or_reducescatter_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uint32_or_reducescatter_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_or_reducescatter_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uint32_or_reducescatter_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uint32_or_reducescatter_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uint32_or_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_or_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_uint64_or_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uint64_or_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_or_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uint64_or_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL37nvshmemx_uint64_or_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uint64_or_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uint64_or_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_or_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uint64_or_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uint64_or_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uint64_or_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def size_or_reducescatter_warp():
    pass
    

def _lower__ZL35nvshmemx_size_or_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmemx_size_or_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_or_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmemx_size_or_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL35nvshmemx_size_or_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmemx_size_or_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmemx_size_or_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_or_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL35nvshmemx_size_or_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmemx_size_or_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmemx_size_or_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def uchar_xor_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_uchar_xor_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uchar_xor_reducescatter_warpiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_xor_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uchar_xor_reducescatter_warpiPhPKhm_nbst = declare_device(
        '_ZL37nvshmemx_uchar_xor_reducescatter_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uchar_xor_reducescatter_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uchar_xor_reducescatter_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_xor_reducescatter_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uchar_xor_reducescatter_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uchar_xor_reducescatter_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uchar_xor_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_xor_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_ushort_xor_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_ushort_xor_reducescatter_warpiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_xor_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_ushort_xor_reducescatter_warpiPtPKtm_nbst = declare_device(
        '_ZL38nvshmemx_ushort_xor_reducescatter_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_ushort_xor_reducescatter_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_ushort_xor_reducescatter_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_xor_reducescatter_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_ushort_xor_reducescatter_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_ushort_xor_reducescatter_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_ushort_xor_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint_xor_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_uint_xor_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_uint_xor_reducescatter_warpiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_xor_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_uint_xor_reducescatter_warpiPjPKjm_nbst = declare_device(
        '_ZL36nvshmemx_uint_xor_reducescatter_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_uint_xor_reducescatter_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_uint_xor_reducescatter_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_xor_reducescatter_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_uint_xor_reducescatter_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_uint_xor_reducescatter_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_uint_xor_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_xor_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_ulong_xor_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_ulong_xor_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_xor_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_ulong_xor_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL37nvshmemx_ulong_xor_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_ulong_xor_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_ulong_xor_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_xor_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_ulong_xor_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_ulong_xor_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_ulong_xor_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_xor_reducescatter_warp():
    pass
    

def _lower__ZL41nvshmemx_ulonglong_xor_reducescatter_warpiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL41nvshmemx_ulonglong_xor_reducescatter_warpiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_xor_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL41nvshmemx_ulonglong_xor_reducescatter_warpiPyPKym_nbst = declare_device(
        '_ZL41nvshmemx_ulonglong_xor_reducescatter_warpiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL41nvshmemx_ulonglong_xor_reducescatter_warpiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL41nvshmemx_ulonglong_xor_reducescatter_warpiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_xor_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL41nvshmemx_ulonglong_xor_reducescatter_warpiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL41nvshmemx_ulonglong_xor_reducescatter_warpiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL41nvshmemx_ulonglong_xor_reducescatter_warpiPyPKym_nbst(shim_stream, shim_obj)


def int8_xor_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_int8_xor_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_int8_xor_reducescatter_warpiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_xor_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_int8_xor_reducescatter_warpiPaPKam_nbst = declare_device(
        '_ZL36nvshmemx_int8_xor_reducescatter_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_int8_xor_reducescatter_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_int8_xor_reducescatter_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_xor_reducescatter_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_int8_xor_reducescatter_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_int8_xor_reducescatter_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_int8_xor_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj)


def int16_xor_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_int16_xor_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int16_xor_reducescatter_warpiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_xor_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int16_xor_reducescatter_warpiPsPKsm_nbst = declare_device(
        '_ZL37nvshmemx_int16_xor_reducescatter_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int16_xor_reducescatter_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int16_xor_reducescatter_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_xor_reducescatter_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int16_xor_reducescatter_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int16_xor_reducescatter_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int16_xor_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int32_xor_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_int32_xor_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int32_xor_reducescatter_warpiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_xor_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int32_xor_reducescatter_warpiPiPKim_nbst = declare_device(
        '_ZL37nvshmemx_int32_xor_reducescatter_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int32_xor_reducescatter_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int32_xor_reducescatter_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_xor_reducescatter_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int32_xor_reducescatter_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int32_xor_reducescatter_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int32_xor_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj)


def int64_xor_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_int64_xor_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int64_xor_reducescatter_warpiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_xor_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int64_xor_reducescatter_warpiPlPKlm_nbst = declare_device(
        '_ZL37nvshmemx_int64_xor_reducescatter_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int64_xor_reducescatter_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int64_xor_reducescatter_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_xor_reducescatter_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int64_xor_reducescatter_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int64_xor_reducescatter_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int64_xor_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_xor_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_uint8_xor_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uint8_xor_reducescatter_warpiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_xor_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uint8_xor_reducescatter_warpiPhPKhm_nbst = declare_device(
        '_ZL37nvshmemx_uint8_xor_reducescatter_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uint8_xor_reducescatter_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uint8_xor_reducescatter_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_xor_reducescatter_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uint8_xor_reducescatter_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uint8_xor_reducescatter_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uint8_xor_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_xor_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_uint16_xor_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint16_xor_reducescatter_warpiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_xor_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint16_xor_reducescatter_warpiPtPKtm_nbst = declare_device(
        '_ZL38nvshmemx_uint16_xor_reducescatter_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint16_xor_reducescatter_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint16_xor_reducescatter_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_xor_reducescatter_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint16_xor_reducescatter_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint16_xor_reducescatter_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint16_xor_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_xor_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_uint32_xor_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint32_xor_reducescatter_warpiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_xor_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint32_xor_reducescatter_warpiPjPKjm_nbst = declare_device(
        '_ZL38nvshmemx_uint32_xor_reducescatter_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint32_xor_reducescatter_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint32_xor_reducescatter_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_xor_reducescatter_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint32_xor_reducescatter_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint32_xor_reducescatter_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint32_xor_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_xor_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_uint64_xor_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint64_xor_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_xor_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint64_xor_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL38nvshmemx_uint64_xor_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint64_xor_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint64_xor_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_xor_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint64_xor_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint64_xor_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint64_xor_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def size_xor_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_size_xor_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_size_xor_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_xor_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_size_xor_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL36nvshmemx_size_xor_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_size_xor_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_size_xor_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_xor_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_size_xor_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_size_xor_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_size_xor_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def uchar_max_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_uchar_max_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uchar_max_reducescatter_warpiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uchar_max_reducescatter_warpiPhPKhm_nbst = declare_device(
        '_ZL37nvshmemx_uchar_max_reducescatter_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uchar_max_reducescatter_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uchar_max_reducescatter_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_max_reducescatter_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uchar_max_reducescatter_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uchar_max_reducescatter_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uchar_max_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_max_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_ushort_max_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_ushort_max_reducescatter_warpiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_ushort_max_reducescatter_warpiPtPKtm_nbst = declare_device(
        '_ZL38nvshmemx_ushort_max_reducescatter_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_ushort_max_reducescatter_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_ushort_max_reducescatter_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_max_reducescatter_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_ushort_max_reducescatter_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_ushort_max_reducescatter_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_ushort_max_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint_max_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_uint_max_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_uint_max_reducescatter_warpiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_uint_max_reducescatter_warpiPjPKjm_nbst = declare_device(
        '_ZL36nvshmemx_uint_max_reducescatter_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_uint_max_reducescatter_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_uint_max_reducescatter_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_max_reducescatter_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_uint_max_reducescatter_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_uint_max_reducescatter_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_uint_max_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_max_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_ulong_max_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_ulong_max_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_ulong_max_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL37nvshmemx_ulong_max_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_ulong_max_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_ulong_max_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_max_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_ulong_max_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_ulong_max_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_ulong_max_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_max_reducescatter_warp():
    pass
    

def _lower__ZL41nvshmemx_ulonglong_max_reducescatter_warpiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL41nvshmemx_ulonglong_max_reducescatter_warpiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL41nvshmemx_ulonglong_max_reducescatter_warpiPyPKym_nbst = declare_device(
        '_ZL41nvshmemx_ulonglong_max_reducescatter_warpiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL41nvshmemx_ulonglong_max_reducescatter_warpiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL41nvshmemx_ulonglong_max_reducescatter_warpiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_max_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL41nvshmemx_ulonglong_max_reducescatter_warpiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL41nvshmemx_ulonglong_max_reducescatter_warpiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL41nvshmemx_ulonglong_max_reducescatter_warpiPyPKym_nbst(shim_stream, shim_obj)


def int8_max_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_int8_max_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_int8_max_reducescatter_warpiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_int8_max_reducescatter_warpiPaPKam_nbst = declare_device(
        '_ZL36nvshmemx_int8_max_reducescatter_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_int8_max_reducescatter_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_int8_max_reducescatter_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_max_reducescatter_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_int8_max_reducescatter_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_int8_max_reducescatter_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_int8_max_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj)


def int16_max_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_int16_max_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int16_max_reducescatter_warpiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int16_max_reducescatter_warpiPsPKsm_nbst = declare_device(
        '_ZL37nvshmemx_int16_max_reducescatter_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int16_max_reducescatter_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int16_max_reducescatter_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_max_reducescatter_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int16_max_reducescatter_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int16_max_reducescatter_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int16_max_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int32_max_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_int32_max_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int32_max_reducescatter_warpiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int32_max_reducescatter_warpiPiPKim_nbst = declare_device(
        '_ZL37nvshmemx_int32_max_reducescatter_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int32_max_reducescatter_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int32_max_reducescatter_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_max_reducescatter_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int32_max_reducescatter_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int32_max_reducescatter_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int32_max_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj)


def int64_max_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_int64_max_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int64_max_reducescatter_warpiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int64_max_reducescatter_warpiPlPKlm_nbst = declare_device(
        '_ZL37nvshmemx_int64_max_reducescatter_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int64_max_reducescatter_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int64_max_reducescatter_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_max_reducescatter_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int64_max_reducescatter_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int64_max_reducescatter_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int64_max_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_max_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_uint8_max_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uint8_max_reducescatter_warpiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uint8_max_reducescatter_warpiPhPKhm_nbst = declare_device(
        '_ZL37nvshmemx_uint8_max_reducescatter_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uint8_max_reducescatter_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uint8_max_reducescatter_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_max_reducescatter_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uint8_max_reducescatter_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uint8_max_reducescatter_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uint8_max_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_max_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_uint16_max_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint16_max_reducescatter_warpiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint16_max_reducescatter_warpiPtPKtm_nbst = declare_device(
        '_ZL38nvshmemx_uint16_max_reducescatter_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint16_max_reducescatter_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint16_max_reducescatter_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_max_reducescatter_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint16_max_reducescatter_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint16_max_reducescatter_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint16_max_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_max_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_uint32_max_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint32_max_reducescatter_warpiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint32_max_reducescatter_warpiPjPKjm_nbst = declare_device(
        '_ZL38nvshmemx_uint32_max_reducescatter_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint32_max_reducescatter_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint32_max_reducescatter_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_max_reducescatter_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint32_max_reducescatter_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint32_max_reducescatter_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint32_max_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_max_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_uint64_max_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint64_max_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint64_max_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL38nvshmemx_uint64_max_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint64_max_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint64_max_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_max_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint64_max_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint64_max_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint64_max_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def size_max_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_size_max_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_size_max_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_size_max_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL36nvshmemx_size_max_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_size_max_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_size_max_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_max_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_size_max_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_size_max_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_size_max_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def char_max_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_char_max_reducescatter_warpiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_char_max_reducescatter_warpiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmemx_char_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_char_max_reducescatter_warpiPcPKcm_nbst = declare_device(
        '_ZL36nvshmemx_char_max_reducescatter_warpiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_char_max_reducescatter_warpiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_char_max_reducescatter_warpiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_max_reducescatter_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_char_max_reducescatter_warpiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_char_max_reducescatter_warpiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_char_max_reducescatter_warpiPcPKcm_nbst(shim_stream, shim_obj)


def schar_max_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_schar_max_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_schar_max_reducescatter_warpiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmemx_schar_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_schar_max_reducescatter_warpiPaPKam_nbst = declare_device(
        '_ZL37nvshmemx_schar_max_reducescatter_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_schar_max_reducescatter_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_schar_max_reducescatter_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_max_reducescatter_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_schar_max_reducescatter_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_schar_max_reducescatter_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_schar_max_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj)


def short_max_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_short_max_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_short_max_reducescatter_warpiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmemx_short_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_short_max_reducescatter_warpiPsPKsm_nbst = declare_device(
        '_ZL37nvshmemx_short_max_reducescatter_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_short_max_reducescatter_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_short_max_reducescatter_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_max_reducescatter_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_short_max_reducescatter_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_short_max_reducescatter_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_short_max_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int_max_reducescatter_warp():
    pass
    

def _lower__ZL35nvshmemx_int_max_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmemx_int_max_reducescatter_warpiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmemx_int_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmemx_int_max_reducescatter_warpiPiPKim_nbst = declare_device(
        '_ZL35nvshmemx_int_max_reducescatter_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmemx_int_max_reducescatter_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmemx_int_max_reducescatter_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_max_reducescatter_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL35nvshmemx_int_max_reducescatter_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmemx_int_max_reducescatter_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmemx_int_max_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj)


def long_max_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_long_max_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_long_max_reducescatter_warpiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmemx_long_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_long_max_reducescatter_warpiPlPKlm_nbst = declare_device(
        '_ZL36nvshmemx_long_max_reducescatter_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_long_max_reducescatter_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_long_max_reducescatter_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_max_reducescatter_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_long_max_reducescatter_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_long_max_reducescatter_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_long_max_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_max_reducescatter_warp():
    pass
    

def _lower__ZL40nvshmemx_longlong_max_reducescatter_warpiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL40nvshmemx_longlong_max_reducescatter_warpiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_longlong_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL40nvshmemx_longlong_max_reducescatter_warpiPxPKxm_nbst = declare_device(
        '_ZL40nvshmemx_longlong_max_reducescatter_warpiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL40nvshmemx_longlong_max_reducescatter_warpiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL40nvshmemx_longlong_max_reducescatter_warpiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_max_reducescatter_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL40nvshmemx_longlong_max_reducescatter_warpiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL40nvshmemx_longlong_max_reducescatter_warpiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL40nvshmemx_longlong_max_reducescatter_warpiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_max_reducescatter_warp():
    pass
    

def _lower__ZL40nvshmemx_bfloat16_max_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL40nvshmemx_bfloat16_max_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmemx_bfloat16_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL40nvshmemx_bfloat16_max_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL40nvshmemx_bfloat16_max_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL40nvshmemx_bfloat16_max_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL40nvshmemx_bfloat16_max_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_max_reducescatter_warp, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL40nvshmemx_bfloat16_max_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL40nvshmemx_bfloat16_max_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL40nvshmemx_bfloat16_max_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_max_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_half_max_reducescatter_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_half_max_reducescatter_warpiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmemx_half_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_half_max_reducescatter_warpiP6__halfPKS_m_nbst = declare_device(
        '_ZL36nvshmemx_half_max_reducescatter_warpiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_half_max_reducescatter_warpiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_half_max_reducescatter_warpiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_max_reducescatter_warp, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_half_max_reducescatter_warpiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_half_max_reducescatter_warpiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_half_max_reducescatter_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_max_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_float_max_reducescatter_warpiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_float_max_reducescatter_warpiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmemx_float_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_float_max_reducescatter_warpiPfPKfm_nbst = declare_device(
        '_ZL37nvshmemx_float_max_reducescatter_warpiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_float_max_reducescatter_warpiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_float_max_reducescatter_warpiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_max_reducescatter_warp, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_float_max_reducescatter_warpiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_float_max_reducescatter_warpiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_float_max_reducescatter_warpiPfPKfm_nbst(shim_stream, shim_obj)


def double_max_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_double_max_reducescatter_warpiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_double_max_reducescatter_warpiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmemx_double_max_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_double_max_reducescatter_warpiPdPKdm_nbst = declare_device(
        '_ZL38nvshmemx_double_max_reducescatter_warpiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_double_max_reducescatter_warpiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_double_max_reducescatter_warpiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_max_reducescatter_warp, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_double_max_reducescatter_warpiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_double_max_reducescatter_warpiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_double_max_reducescatter_warpiPdPKdm_nbst(shim_stream, shim_obj)


def uchar_min_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_uchar_min_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uchar_min_reducescatter_warpiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uchar_min_reducescatter_warpiPhPKhm_nbst = declare_device(
        '_ZL37nvshmemx_uchar_min_reducescatter_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uchar_min_reducescatter_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uchar_min_reducescatter_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_min_reducescatter_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uchar_min_reducescatter_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uchar_min_reducescatter_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uchar_min_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_min_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_ushort_min_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_ushort_min_reducescatter_warpiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_ushort_min_reducescatter_warpiPtPKtm_nbst = declare_device(
        '_ZL38nvshmemx_ushort_min_reducescatter_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_ushort_min_reducescatter_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_ushort_min_reducescatter_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_min_reducescatter_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_ushort_min_reducescatter_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_ushort_min_reducescatter_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_ushort_min_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint_min_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_uint_min_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_uint_min_reducescatter_warpiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_uint_min_reducescatter_warpiPjPKjm_nbst = declare_device(
        '_ZL36nvshmemx_uint_min_reducescatter_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_uint_min_reducescatter_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_uint_min_reducescatter_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_min_reducescatter_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_uint_min_reducescatter_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_uint_min_reducescatter_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_uint_min_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_min_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_ulong_min_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_ulong_min_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_ulong_min_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL37nvshmemx_ulong_min_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_ulong_min_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_ulong_min_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_min_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_ulong_min_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_ulong_min_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_ulong_min_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_min_reducescatter_warp():
    pass
    

def _lower__ZL41nvshmemx_ulonglong_min_reducescatter_warpiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL41nvshmemx_ulonglong_min_reducescatter_warpiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL41nvshmemx_ulonglong_min_reducescatter_warpiPyPKym_nbst = declare_device(
        '_ZL41nvshmemx_ulonglong_min_reducescatter_warpiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL41nvshmemx_ulonglong_min_reducescatter_warpiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL41nvshmemx_ulonglong_min_reducescatter_warpiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_min_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL41nvshmemx_ulonglong_min_reducescatter_warpiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL41nvshmemx_ulonglong_min_reducescatter_warpiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL41nvshmemx_ulonglong_min_reducescatter_warpiPyPKym_nbst(shim_stream, shim_obj)


def int8_min_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_int8_min_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_int8_min_reducescatter_warpiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_int8_min_reducescatter_warpiPaPKam_nbst = declare_device(
        '_ZL36nvshmemx_int8_min_reducescatter_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_int8_min_reducescatter_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_int8_min_reducescatter_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_min_reducescatter_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_int8_min_reducescatter_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_int8_min_reducescatter_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_int8_min_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj)


def int16_min_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_int16_min_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int16_min_reducescatter_warpiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int16_min_reducescatter_warpiPsPKsm_nbst = declare_device(
        '_ZL37nvshmemx_int16_min_reducescatter_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int16_min_reducescatter_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int16_min_reducescatter_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_min_reducescatter_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int16_min_reducescatter_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int16_min_reducescatter_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int16_min_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int32_min_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_int32_min_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int32_min_reducescatter_warpiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int32_min_reducescatter_warpiPiPKim_nbst = declare_device(
        '_ZL37nvshmemx_int32_min_reducescatter_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int32_min_reducescatter_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int32_min_reducescatter_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_min_reducescatter_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int32_min_reducescatter_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int32_min_reducescatter_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int32_min_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj)


def int64_min_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_int64_min_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int64_min_reducescatter_warpiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int64_min_reducescatter_warpiPlPKlm_nbst = declare_device(
        '_ZL37nvshmemx_int64_min_reducescatter_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int64_min_reducescatter_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int64_min_reducescatter_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_min_reducescatter_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int64_min_reducescatter_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int64_min_reducescatter_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int64_min_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_min_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_uint8_min_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uint8_min_reducescatter_warpiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uint8_min_reducescatter_warpiPhPKhm_nbst = declare_device(
        '_ZL37nvshmemx_uint8_min_reducescatter_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uint8_min_reducescatter_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uint8_min_reducescatter_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_min_reducescatter_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uint8_min_reducescatter_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uint8_min_reducescatter_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uint8_min_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_min_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_uint16_min_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint16_min_reducescatter_warpiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint16_min_reducescatter_warpiPtPKtm_nbst = declare_device(
        '_ZL38nvshmemx_uint16_min_reducescatter_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint16_min_reducescatter_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint16_min_reducescatter_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_min_reducescatter_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint16_min_reducescatter_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint16_min_reducescatter_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint16_min_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_min_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_uint32_min_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint32_min_reducescatter_warpiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint32_min_reducescatter_warpiPjPKjm_nbst = declare_device(
        '_ZL38nvshmemx_uint32_min_reducescatter_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint32_min_reducescatter_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint32_min_reducescatter_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_min_reducescatter_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint32_min_reducescatter_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint32_min_reducescatter_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint32_min_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_min_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_uint64_min_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint64_min_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint64_min_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL38nvshmemx_uint64_min_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint64_min_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint64_min_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_min_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint64_min_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint64_min_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint64_min_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def size_min_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_size_min_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_size_min_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_size_min_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL36nvshmemx_size_min_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_size_min_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_size_min_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_min_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_size_min_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_size_min_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_size_min_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def char_min_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_char_min_reducescatter_warpiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_char_min_reducescatter_warpiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmemx_char_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_char_min_reducescatter_warpiPcPKcm_nbst = declare_device(
        '_ZL36nvshmemx_char_min_reducescatter_warpiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_char_min_reducescatter_warpiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_char_min_reducescatter_warpiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_min_reducescatter_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_char_min_reducescatter_warpiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_char_min_reducescatter_warpiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_char_min_reducescatter_warpiPcPKcm_nbst(shim_stream, shim_obj)


def schar_min_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_schar_min_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_schar_min_reducescatter_warpiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmemx_schar_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_schar_min_reducescatter_warpiPaPKam_nbst = declare_device(
        '_ZL37nvshmemx_schar_min_reducescatter_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_schar_min_reducescatter_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_schar_min_reducescatter_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_min_reducescatter_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_schar_min_reducescatter_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_schar_min_reducescatter_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_schar_min_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj)


def short_min_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_short_min_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_short_min_reducescatter_warpiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmemx_short_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_short_min_reducescatter_warpiPsPKsm_nbst = declare_device(
        '_ZL37nvshmemx_short_min_reducescatter_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_short_min_reducescatter_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_short_min_reducescatter_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_min_reducescatter_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_short_min_reducescatter_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_short_min_reducescatter_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_short_min_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int_min_reducescatter_warp():
    pass
    

def _lower__ZL35nvshmemx_int_min_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmemx_int_min_reducescatter_warpiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmemx_int_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmemx_int_min_reducescatter_warpiPiPKim_nbst = declare_device(
        '_ZL35nvshmemx_int_min_reducescatter_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmemx_int_min_reducescatter_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmemx_int_min_reducescatter_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_min_reducescatter_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL35nvshmemx_int_min_reducescatter_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmemx_int_min_reducescatter_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmemx_int_min_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj)


def long_min_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_long_min_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_long_min_reducescatter_warpiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmemx_long_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_long_min_reducescatter_warpiPlPKlm_nbst = declare_device(
        '_ZL36nvshmemx_long_min_reducescatter_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_long_min_reducescatter_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_long_min_reducescatter_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_min_reducescatter_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_long_min_reducescatter_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_long_min_reducescatter_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_long_min_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_min_reducescatter_warp():
    pass
    

def _lower__ZL40nvshmemx_longlong_min_reducescatter_warpiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL40nvshmemx_longlong_min_reducescatter_warpiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_longlong_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL40nvshmemx_longlong_min_reducescatter_warpiPxPKxm_nbst = declare_device(
        '_ZL40nvshmemx_longlong_min_reducescatter_warpiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL40nvshmemx_longlong_min_reducescatter_warpiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL40nvshmemx_longlong_min_reducescatter_warpiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_min_reducescatter_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL40nvshmemx_longlong_min_reducescatter_warpiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL40nvshmemx_longlong_min_reducescatter_warpiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL40nvshmemx_longlong_min_reducescatter_warpiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_min_reducescatter_warp():
    pass
    

def _lower__ZL40nvshmemx_bfloat16_min_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL40nvshmemx_bfloat16_min_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmemx_bfloat16_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL40nvshmemx_bfloat16_min_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL40nvshmemx_bfloat16_min_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL40nvshmemx_bfloat16_min_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL40nvshmemx_bfloat16_min_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_min_reducescatter_warp, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL40nvshmemx_bfloat16_min_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL40nvshmemx_bfloat16_min_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL40nvshmemx_bfloat16_min_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_min_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_half_min_reducescatter_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_half_min_reducescatter_warpiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmemx_half_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_half_min_reducescatter_warpiP6__halfPKS_m_nbst = declare_device(
        '_ZL36nvshmemx_half_min_reducescatter_warpiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_half_min_reducescatter_warpiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_half_min_reducescatter_warpiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_min_reducescatter_warp, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_half_min_reducescatter_warpiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_half_min_reducescatter_warpiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_half_min_reducescatter_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_min_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_float_min_reducescatter_warpiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_float_min_reducescatter_warpiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmemx_float_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_float_min_reducescatter_warpiPfPKfm_nbst = declare_device(
        '_ZL37nvshmemx_float_min_reducescatter_warpiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_float_min_reducescatter_warpiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_float_min_reducescatter_warpiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_min_reducescatter_warp, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_float_min_reducescatter_warpiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_float_min_reducescatter_warpiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_float_min_reducescatter_warpiPfPKfm_nbst(shim_stream, shim_obj)


def double_min_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_double_min_reducescatter_warpiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_double_min_reducescatter_warpiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmemx_double_min_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_double_min_reducescatter_warpiPdPKdm_nbst = declare_device(
        '_ZL38nvshmemx_double_min_reducescatter_warpiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_double_min_reducescatter_warpiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_double_min_reducescatter_warpiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_min_reducescatter_warp, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_double_min_reducescatter_warpiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_double_min_reducescatter_warpiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_double_min_reducescatter_warpiPdPKdm_nbst(shim_stream, shim_obj)


def uchar_sum_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_uchar_sum_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uchar_sum_reducescatter_warpiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uchar_sum_reducescatter_warpiPhPKhm_nbst = declare_device(
        '_ZL37nvshmemx_uchar_sum_reducescatter_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uchar_sum_reducescatter_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uchar_sum_reducescatter_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_sum_reducescatter_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uchar_sum_reducescatter_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uchar_sum_reducescatter_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uchar_sum_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_sum_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_ushort_sum_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_ushort_sum_reducescatter_warpiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_ushort_sum_reducescatter_warpiPtPKtm_nbst = declare_device(
        '_ZL38nvshmemx_ushort_sum_reducescatter_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_ushort_sum_reducescatter_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_ushort_sum_reducescatter_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_sum_reducescatter_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_ushort_sum_reducescatter_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_ushort_sum_reducescatter_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_ushort_sum_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint_sum_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_uint_sum_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_uint_sum_reducescatter_warpiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_uint_sum_reducescatter_warpiPjPKjm_nbst = declare_device(
        '_ZL36nvshmemx_uint_sum_reducescatter_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_uint_sum_reducescatter_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_uint_sum_reducescatter_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_sum_reducescatter_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_uint_sum_reducescatter_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_uint_sum_reducescatter_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_uint_sum_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_sum_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_ulong_sum_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_ulong_sum_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_ulong_sum_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL37nvshmemx_ulong_sum_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_ulong_sum_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_ulong_sum_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_sum_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_ulong_sum_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_ulong_sum_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_ulong_sum_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_sum_reducescatter_warp():
    pass
    

def _lower__ZL41nvshmemx_ulonglong_sum_reducescatter_warpiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL41nvshmemx_ulonglong_sum_reducescatter_warpiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL41nvshmemx_ulonglong_sum_reducescatter_warpiPyPKym_nbst = declare_device(
        '_ZL41nvshmemx_ulonglong_sum_reducescatter_warpiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL41nvshmemx_ulonglong_sum_reducescatter_warpiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL41nvshmemx_ulonglong_sum_reducescatter_warpiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_sum_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL41nvshmemx_ulonglong_sum_reducescatter_warpiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL41nvshmemx_ulonglong_sum_reducescatter_warpiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL41nvshmemx_ulonglong_sum_reducescatter_warpiPyPKym_nbst(shim_stream, shim_obj)


def int8_sum_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_int8_sum_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_int8_sum_reducescatter_warpiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_int8_sum_reducescatter_warpiPaPKam_nbst = declare_device(
        '_ZL36nvshmemx_int8_sum_reducescatter_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_int8_sum_reducescatter_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_int8_sum_reducescatter_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_sum_reducescatter_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_int8_sum_reducescatter_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_int8_sum_reducescatter_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_int8_sum_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj)


def int16_sum_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_int16_sum_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int16_sum_reducescatter_warpiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int16_sum_reducescatter_warpiPsPKsm_nbst = declare_device(
        '_ZL37nvshmemx_int16_sum_reducescatter_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int16_sum_reducescatter_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int16_sum_reducescatter_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_sum_reducescatter_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int16_sum_reducescatter_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int16_sum_reducescatter_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int16_sum_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int32_sum_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_int32_sum_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int32_sum_reducescatter_warpiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int32_sum_reducescatter_warpiPiPKim_nbst = declare_device(
        '_ZL37nvshmemx_int32_sum_reducescatter_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int32_sum_reducescatter_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int32_sum_reducescatter_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_sum_reducescatter_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int32_sum_reducescatter_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int32_sum_reducescatter_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int32_sum_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj)


def int64_sum_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_int64_sum_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int64_sum_reducescatter_warpiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int64_sum_reducescatter_warpiPlPKlm_nbst = declare_device(
        '_ZL37nvshmemx_int64_sum_reducescatter_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int64_sum_reducescatter_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int64_sum_reducescatter_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_sum_reducescatter_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int64_sum_reducescatter_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int64_sum_reducescatter_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int64_sum_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_sum_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_uint8_sum_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uint8_sum_reducescatter_warpiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uint8_sum_reducescatter_warpiPhPKhm_nbst = declare_device(
        '_ZL37nvshmemx_uint8_sum_reducescatter_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uint8_sum_reducescatter_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uint8_sum_reducescatter_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_sum_reducescatter_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uint8_sum_reducescatter_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uint8_sum_reducescatter_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uint8_sum_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_sum_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_uint16_sum_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint16_sum_reducescatter_warpiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint16_sum_reducescatter_warpiPtPKtm_nbst = declare_device(
        '_ZL38nvshmemx_uint16_sum_reducescatter_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint16_sum_reducescatter_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint16_sum_reducescatter_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_sum_reducescatter_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint16_sum_reducescatter_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint16_sum_reducescatter_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint16_sum_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_sum_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_uint32_sum_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint32_sum_reducescatter_warpiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint32_sum_reducescatter_warpiPjPKjm_nbst = declare_device(
        '_ZL38nvshmemx_uint32_sum_reducescatter_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint32_sum_reducescatter_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint32_sum_reducescatter_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_sum_reducescatter_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint32_sum_reducescatter_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint32_sum_reducescatter_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint32_sum_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_sum_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_uint64_sum_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint64_sum_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint64_sum_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL38nvshmemx_uint64_sum_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint64_sum_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint64_sum_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_sum_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint64_sum_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint64_sum_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint64_sum_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def size_sum_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_size_sum_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_size_sum_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_size_sum_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL36nvshmemx_size_sum_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_size_sum_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_size_sum_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_sum_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_size_sum_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_size_sum_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_size_sum_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def char_sum_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_char_sum_reducescatter_warpiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_char_sum_reducescatter_warpiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmemx_char_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_char_sum_reducescatter_warpiPcPKcm_nbst = declare_device(
        '_ZL36nvshmemx_char_sum_reducescatter_warpiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_char_sum_reducescatter_warpiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_char_sum_reducescatter_warpiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_sum_reducescatter_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_char_sum_reducescatter_warpiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_char_sum_reducescatter_warpiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_char_sum_reducescatter_warpiPcPKcm_nbst(shim_stream, shim_obj)


def schar_sum_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_schar_sum_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_schar_sum_reducescatter_warpiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmemx_schar_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_schar_sum_reducescatter_warpiPaPKam_nbst = declare_device(
        '_ZL37nvshmemx_schar_sum_reducescatter_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_schar_sum_reducescatter_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_schar_sum_reducescatter_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_sum_reducescatter_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_schar_sum_reducescatter_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_schar_sum_reducescatter_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_schar_sum_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj)


def short_sum_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_short_sum_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_short_sum_reducescatter_warpiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmemx_short_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_short_sum_reducescatter_warpiPsPKsm_nbst = declare_device(
        '_ZL37nvshmemx_short_sum_reducescatter_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_short_sum_reducescatter_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_short_sum_reducescatter_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_sum_reducescatter_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_short_sum_reducescatter_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_short_sum_reducescatter_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_short_sum_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int_sum_reducescatter_warp():
    pass
    

def _lower__ZL35nvshmemx_int_sum_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL35nvshmemx_int_sum_reducescatter_warpiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmemx_int_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL35nvshmemx_int_sum_reducescatter_warpiPiPKim_nbst = declare_device(
        '_ZL35nvshmemx_int_sum_reducescatter_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL35nvshmemx_int_sum_reducescatter_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL35nvshmemx_int_sum_reducescatter_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_sum_reducescatter_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL35nvshmemx_int_sum_reducescatter_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL35nvshmemx_int_sum_reducescatter_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL35nvshmemx_int_sum_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj)


def long_sum_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_long_sum_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_long_sum_reducescatter_warpiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmemx_long_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_long_sum_reducescatter_warpiPlPKlm_nbst = declare_device(
        '_ZL36nvshmemx_long_sum_reducescatter_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_long_sum_reducescatter_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_long_sum_reducescatter_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_sum_reducescatter_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_long_sum_reducescatter_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_long_sum_reducescatter_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_long_sum_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_sum_reducescatter_warp():
    pass
    

def _lower__ZL40nvshmemx_longlong_sum_reducescatter_warpiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL40nvshmemx_longlong_sum_reducescatter_warpiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_longlong_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL40nvshmemx_longlong_sum_reducescatter_warpiPxPKxm_nbst = declare_device(
        '_ZL40nvshmemx_longlong_sum_reducescatter_warpiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL40nvshmemx_longlong_sum_reducescatter_warpiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL40nvshmemx_longlong_sum_reducescatter_warpiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_sum_reducescatter_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL40nvshmemx_longlong_sum_reducescatter_warpiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL40nvshmemx_longlong_sum_reducescatter_warpiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL40nvshmemx_longlong_sum_reducescatter_warpiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_sum_reducescatter_warp():
    pass
    

def _lower__ZL40nvshmemx_bfloat16_sum_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL40nvshmemx_bfloat16_sum_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmemx_bfloat16_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL40nvshmemx_bfloat16_sum_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL40nvshmemx_bfloat16_sum_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL40nvshmemx_bfloat16_sum_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL40nvshmemx_bfloat16_sum_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_sum_reducescatter_warp, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL40nvshmemx_bfloat16_sum_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL40nvshmemx_bfloat16_sum_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL40nvshmemx_bfloat16_sum_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_sum_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_half_sum_reducescatter_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_half_sum_reducescatter_warpiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmemx_half_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_half_sum_reducescatter_warpiP6__halfPKS_m_nbst = declare_device(
        '_ZL36nvshmemx_half_sum_reducescatter_warpiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_half_sum_reducescatter_warpiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_half_sum_reducescatter_warpiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_sum_reducescatter_warp, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_half_sum_reducescatter_warpiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_half_sum_reducescatter_warpiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_half_sum_reducescatter_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_sum_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_float_sum_reducescatter_warpiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_float_sum_reducescatter_warpiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmemx_float_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_float_sum_reducescatter_warpiPfPKfm_nbst = declare_device(
        '_ZL37nvshmemx_float_sum_reducescatter_warpiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_float_sum_reducescatter_warpiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_float_sum_reducescatter_warpiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_sum_reducescatter_warp, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_float_sum_reducescatter_warpiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_float_sum_reducescatter_warpiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_float_sum_reducescatter_warpiPfPKfm_nbst(shim_stream, shim_obj)


def double_sum_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_double_sum_reducescatter_warpiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_double_sum_reducescatter_warpiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmemx_double_sum_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_double_sum_reducescatter_warpiPdPKdm_nbst = declare_device(
        '_ZL38nvshmemx_double_sum_reducescatter_warpiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_double_sum_reducescatter_warpiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_double_sum_reducescatter_warpiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_sum_reducescatter_warp, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_double_sum_reducescatter_warpiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_double_sum_reducescatter_warpiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_double_sum_reducescatter_warpiPdPKdm_nbst(shim_stream, shim_obj)


def uchar_prod_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_uchar_prod_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uchar_prod_reducescatter_warpiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uchar_prod_reducescatter_warpiPhPKhm_nbst = declare_device(
        '_ZL38nvshmemx_uchar_prod_reducescatter_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uchar_prod_reducescatter_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uchar_prod_reducescatter_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_prod_reducescatter_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uchar_prod_reducescatter_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uchar_prod_reducescatter_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uchar_prod_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_prod_reducescatter_warp():
    pass
    

def _lower__ZL39nvshmemx_ushort_prod_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_ushort_prod_reducescatter_warpiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_ushort_prod_reducescatter_warpiPtPKtm_nbst = declare_device(
        '_ZL39nvshmemx_ushort_prod_reducescatter_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_ushort_prod_reducescatter_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_ushort_prod_reducescatter_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_prod_reducescatter_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_ushort_prod_reducescatter_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_ushort_prod_reducescatter_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_ushort_prod_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint_prod_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_uint_prod_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uint_prod_reducescatter_warpiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uint_prod_reducescatter_warpiPjPKjm_nbst = declare_device(
        '_ZL37nvshmemx_uint_prod_reducescatter_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uint_prod_reducescatter_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uint_prod_reducescatter_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_prod_reducescatter_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uint_prod_reducescatter_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uint_prod_reducescatter_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uint_prod_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_prod_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_ulong_prod_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_ulong_prod_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_ulong_prod_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL38nvshmemx_ulong_prod_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_ulong_prod_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_ulong_prod_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_prod_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_ulong_prod_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_ulong_prod_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_ulong_prod_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_prod_reducescatter_warp():
    pass
    

def _lower__ZL42nvshmemx_ulonglong_prod_reducescatter_warpiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL42nvshmemx_ulonglong_prod_reducescatter_warpiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL42nvshmemx_ulonglong_prod_reducescatter_warpiPyPKym_nbst = declare_device(
        '_ZL42nvshmemx_ulonglong_prod_reducescatter_warpiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL42nvshmemx_ulonglong_prod_reducescatter_warpiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL42nvshmemx_ulonglong_prod_reducescatter_warpiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_prod_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL42nvshmemx_ulonglong_prod_reducescatter_warpiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL42nvshmemx_ulonglong_prod_reducescatter_warpiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL42nvshmemx_ulonglong_prod_reducescatter_warpiPyPKym_nbst(shim_stream, shim_obj)


def int8_prod_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_int8_prod_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int8_prod_reducescatter_warpiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int8_prod_reducescatter_warpiPaPKam_nbst = declare_device(
        '_ZL37nvshmemx_int8_prod_reducescatter_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int8_prod_reducescatter_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int8_prod_reducescatter_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_prod_reducescatter_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int8_prod_reducescatter_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int8_prod_reducescatter_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int8_prod_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj)


def int16_prod_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_int16_prod_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_int16_prod_reducescatter_warpiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_int16_prod_reducescatter_warpiPsPKsm_nbst = declare_device(
        '_ZL38nvshmemx_int16_prod_reducescatter_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_int16_prod_reducescatter_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_int16_prod_reducescatter_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_prod_reducescatter_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_int16_prod_reducescatter_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_int16_prod_reducescatter_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_int16_prod_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int32_prod_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_int32_prod_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_int32_prod_reducescatter_warpiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_int32_prod_reducescatter_warpiPiPKim_nbst = declare_device(
        '_ZL38nvshmemx_int32_prod_reducescatter_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_int32_prod_reducescatter_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_int32_prod_reducescatter_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_prod_reducescatter_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_int32_prod_reducescatter_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_int32_prod_reducescatter_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_int32_prod_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj)


def int64_prod_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_int64_prod_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_int64_prod_reducescatter_warpiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_int64_prod_reducescatter_warpiPlPKlm_nbst = declare_device(
        '_ZL38nvshmemx_int64_prod_reducescatter_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_int64_prod_reducescatter_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_int64_prod_reducescatter_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_prod_reducescatter_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_int64_prod_reducescatter_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_int64_prod_reducescatter_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_int64_prod_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_prod_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_uint8_prod_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint8_prod_reducescatter_warpiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint8_prod_reducescatter_warpiPhPKhm_nbst = declare_device(
        '_ZL38nvshmemx_uint8_prod_reducescatter_warpiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint8_prod_reducescatter_warpiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint8_prod_reducescatter_warpiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_prod_reducescatter_warp, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint8_prod_reducescatter_warpiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint8_prod_reducescatter_warpiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint8_prod_reducescatter_warpiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_prod_reducescatter_warp():
    pass
    

def _lower__ZL39nvshmemx_uint16_prod_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uint16_prod_reducescatter_warpiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uint16_prod_reducescatter_warpiPtPKtm_nbst = declare_device(
        '_ZL39nvshmemx_uint16_prod_reducescatter_warpiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uint16_prod_reducescatter_warpiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uint16_prod_reducescatter_warpiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_prod_reducescatter_warp, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uint16_prod_reducescatter_warpiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uint16_prod_reducescatter_warpiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uint16_prod_reducescatter_warpiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_prod_reducescatter_warp():
    pass
    

def _lower__ZL39nvshmemx_uint32_prod_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uint32_prod_reducescatter_warpiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uint32_prod_reducescatter_warpiPjPKjm_nbst = declare_device(
        '_ZL39nvshmemx_uint32_prod_reducescatter_warpiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uint32_prod_reducescatter_warpiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uint32_prod_reducescatter_warpiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_prod_reducescatter_warp, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uint32_prod_reducescatter_warpiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uint32_prod_reducescatter_warpiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uint32_prod_reducescatter_warpiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_prod_reducescatter_warp():
    pass
    

def _lower__ZL39nvshmemx_uint64_prod_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uint64_prod_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uint64_prod_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL39nvshmemx_uint64_prod_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uint64_prod_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uint64_prod_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_prod_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uint64_prod_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uint64_prod_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uint64_prod_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def size_prod_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_size_prod_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_size_prod_reducescatter_warpiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_size_prod_reducescatter_warpiPmPKmm_nbst = declare_device(
        '_ZL37nvshmemx_size_prod_reducescatter_warpiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_size_prod_reducescatter_warpiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_size_prod_reducescatter_warpiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_prod_reducescatter_warp, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_size_prod_reducescatter_warpiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_size_prod_reducescatter_warpiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_size_prod_reducescatter_warpiPmPKmm_nbst(shim_stream, shim_obj)


def char_prod_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_char_prod_reducescatter_warpiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_char_prod_reducescatter_warpiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmemx_char_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_char_prod_reducescatter_warpiPcPKcm_nbst = declare_device(
        '_ZL37nvshmemx_char_prod_reducescatter_warpiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_char_prod_reducescatter_warpiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_char_prod_reducescatter_warpiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_prod_reducescatter_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_char_prod_reducescatter_warpiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_char_prod_reducescatter_warpiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_char_prod_reducescatter_warpiPcPKcm_nbst(shim_stream, shim_obj)


def schar_prod_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_schar_prod_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_schar_prod_reducescatter_warpiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmemx_schar_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_schar_prod_reducescatter_warpiPaPKam_nbst = declare_device(
        '_ZL38nvshmemx_schar_prod_reducescatter_warpiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_schar_prod_reducescatter_warpiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_schar_prod_reducescatter_warpiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_prod_reducescatter_warp, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_schar_prod_reducescatter_warpiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_schar_prod_reducescatter_warpiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_schar_prod_reducescatter_warpiPaPKam_nbst(shim_stream, shim_obj)


def short_prod_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_short_prod_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_short_prod_reducescatter_warpiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmemx_short_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_short_prod_reducescatter_warpiPsPKsm_nbst = declare_device(
        '_ZL38nvshmemx_short_prod_reducescatter_warpiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_short_prod_reducescatter_warpiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_short_prod_reducescatter_warpiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_prod_reducescatter_warp, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_short_prod_reducescatter_warpiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_short_prod_reducescatter_warpiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_short_prod_reducescatter_warpiPsPKsm_nbst(shim_stream, shim_obj)


def int_prod_reducescatter_warp():
    pass
    

def _lower__ZL36nvshmemx_int_prod_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_int_prod_reducescatter_warpiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmemx_int_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_int_prod_reducescatter_warpiPiPKim_nbst = declare_device(
        '_ZL36nvshmemx_int_prod_reducescatter_warpiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_int_prod_reducescatter_warpiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_int_prod_reducescatter_warpiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_prod_reducescatter_warp, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_int_prod_reducescatter_warpiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_int_prod_reducescatter_warpiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_int_prod_reducescatter_warpiPiPKim_nbst(shim_stream, shim_obj)


def long_prod_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_long_prod_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_long_prod_reducescatter_warpiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmemx_long_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_long_prod_reducescatter_warpiPlPKlm_nbst = declare_device(
        '_ZL37nvshmemx_long_prod_reducescatter_warpiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_long_prod_reducescatter_warpiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_long_prod_reducescatter_warpiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_prod_reducescatter_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_long_prod_reducescatter_warpiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_long_prod_reducescatter_warpiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_long_prod_reducescatter_warpiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_prod_reducescatter_warp():
    pass
    

def _lower__ZL41nvshmemx_longlong_prod_reducescatter_warpiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL41nvshmemx_longlong_prod_reducescatter_warpiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_longlong_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL41nvshmemx_longlong_prod_reducescatter_warpiPxPKxm_nbst = declare_device(
        '_ZL41nvshmemx_longlong_prod_reducescatter_warpiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL41nvshmemx_longlong_prod_reducescatter_warpiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL41nvshmemx_longlong_prod_reducescatter_warpiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_prod_reducescatter_warp, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL41nvshmemx_longlong_prod_reducescatter_warpiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL41nvshmemx_longlong_prod_reducescatter_warpiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL41nvshmemx_longlong_prod_reducescatter_warpiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_prod_reducescatter_warp():
    pass
    

def _lower__ZL41nvshmemx_bfloat16_prod_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL41nvshmemx_bfloat16_prod_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmemx_bfloat16_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL41nvshmemx_bfloat16_prod_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL41nvshmemx_bfloat16_prod_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL41nvshmemx_bfloat16_prod_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL41nvshmemx_bfloat16_prod_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_prod_reducescatter_warp, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL41nvshmemx_bfloat16_prod_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL41nvshmemx_bfloat16_prod_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL41nvshmemx_bfloat16_prod_reducescatter_warpiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_prod_reducescatter_warp():
    pass
    

def _lower__ZL37nvshmemx_half_prod_reducescatter_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_half_prod_reducescatter_warpiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmemx_half_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_half_prod_reducescatter_warpiP6__halfPKS_m_nbst = declare_device(
        '_ZL37nvshmemx_half_prod_reducescatter_warpiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_half_prod_reducescatter_warpiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_half_prod_reducescatter_warpiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_prod_reducescatter_warp, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_half_prod_reducescatter_warpiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_half_prod_reducescatter_warpiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_half_prod_reducescatter_warpiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_prod_reducescatter_warp():
    pass
    

def _lower__ZL38nvshmemx_float_prod_reducescatter_warpiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_float_prod_reducescatter_warpiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmemx_float_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_float_prod_reducescatter_warpiPfPKfm_nbst = declare_device(
        '_ZL38nvshmemx_float_prod_reducescatter_warpiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_float_prod_reducescatter_warpiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_float_prod_reducescatter_warpiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_prod_reducescatter_warp, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_float_prod_reducescatter_warpiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_float_prod_reducescatter_warpiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_float_prod_reducescatter_warpiPfPKfm_nbst(shim_stream, shim_obj)


def double_prod_reducescatter_warp():
    pass
    

def _lower__ZL39nvshmemx_double_prod_reducescatter_warpiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_double_prod_reducescatter_warpiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmemx_double_prod_reducescatter_warp(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_double_prod_reducescatter_warpiPdPKdm_nbst = declare_device(
        '_ZL39nvshmemx_double_prod_reducescatter_warpiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_double_prod_reducescatter_warpiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_double_prod_reducescatter_warpiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_prod_reducescatter_warp, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_double_prod_reducescatter_warpiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_double_prod_reducescatter_warpiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_double_prod_reducescatter_warpiPdPKdm_nbst(shim_stream, shim_obj)


def uchar_and_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_uchar_and_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uchar_and_reducescatter_blockiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_and_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uchar_and_reducescatter_blockiPhPKhm_nbst = declare_device(
        '_ZL38nvshmemx_uchar_and_reducescatter_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uchar_and_reducescatter_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uchar_and_reducescatter_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_and_reducescatter_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uchar_and_reducescatter_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uchar_and_reducescatter_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uchar_and_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_and_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_ushort_and_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_ushort_and_reducescatter_blockiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_and_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_ushort_and_reducescatter_blockiPtPKtm_nbst = declare_device(
        '_ZL39nvshmemx_ushort_and_reducescatter_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_ushort_and_reducescatter_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_ushort_and_reducescatter_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_and_reducescatter_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_ushort_and_reducescatter_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_ushort_and_reducescatter_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_ushort_and_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint_and_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_uint_and_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uint_and_reducescatter_blockiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_and_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uint_and_reducescatter_blockiPjPKjm_nbst = declare_device(
        '_ZL37nvshmemx_uint_and_reducescatter_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uint_and_reducescatter_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uint_and_reducescatter_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_and_reducescatter_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uint_and_reducescatter_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uint_and_reducescatter_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uint_and_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_and_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_ulong_and_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_ulong_and_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_and_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_ulong_and_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL38nvshmemx_ulong_and_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_ulong_and_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_ulong_and_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_and_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_ulong_and_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_ulong_and_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_ulong_and_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_and_reducescatter_block():
    pass
    

def _lower__ZL42nvshmemx_ulonglong_and_reducescatter_blockiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL42nvshmemx_ulonglong_and_reducescatter_blockiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_and_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL42nvshmemx_ulonglong_and_reducescatter_blockiPyPKym_nbst = declare_device(
        '_ZL42nvshmemx_ulonglong_and_reducescatter_blockiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL42nvshmemx_ulonglong_and_reducescatter_blockiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL42nvshmemx_ulonglong_and_reducescatter_blockiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_and_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL42nvshmemx_ulonglong_and_reducescatter_blockiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL42nvshmemx_ulonglong_and_reducescatter_blockiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL42nvshmemx_ulonglong_and_reducescatter_blockiPyPKym_nbst(shim_stream, shim_obj)


def int8_and_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_int8_and_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int8_and_reducescatter_blockiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_and_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int8_and_reducescatter_blockiPaPKam_nbst = declare_device(
        '_ZL37nvshmemx_int8_and_reducescatter_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int8_and_reducescatter_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int8_and_reducescatter_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_and_reducescatter_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int8_and_reducescatter_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int8_and_reducescatter_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int8_and_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj)


def int16_and_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_int16_and_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_int16_and_reducescatter_blockiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_and_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_int16_and_reducescatter_blockiPsPKsm_nbst = declare_device(
        '_ZL38nvshmemx_int16_and_reducescatter_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_int16_and_reducescatter_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_int16_and_reducescatter_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_and_reducescatter_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_int16_and_reducescatter_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_int16_and_reducescatter_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_int16_and_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int32_and_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_int32_and_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_int32_and_reducescatter_blockiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_and_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_int32_and_reducescatter_blockiPiPKim_nbst = declare_device(
        '_ZL38nvshmemx_int32_and_reducescatter_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_int32_and_reducescatter_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_int32_and_reducescatter_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_and_reducescatter_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_int32_and_reducescatter_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_int32_and_reducescatter_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_int32_and_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj)


def int64_and_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_int64_and_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_int64_and_reducescatter_blockiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_and_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_int64_and_reducescatter_blockiPlPKlm_nbst = declare_device(
        '_ZL38nvshmemx_int64_and_reducescatter_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_int64_and_reducescatter_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_int64_and_reducescatter_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_and_reducescatter_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_int64_and_reducescatter_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_int64_and_reducescatter_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_int64_and_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_and_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_uint8_and_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint8_and_reducescatter_blockiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_and_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint8_and_reducescatter_blockiPhPKhm_nbst = declare_device(
        '_ZL38nvshmemx_uint8_and_reducescatter_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint8_and_reducescatter_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint8_and_reducescatter_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_and_reducescatter_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint8_and_reducescatter_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint8_and_reducescatter_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint8_and_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_and_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_uint16_and_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uint16_and_reducescatter_blockiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_and_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uint16_and_reducescatter_blockiPtPKtm_nbst = declare_device(
        '_ZL39nvshmemx_uint16_and_reducescatter_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uint16_and_reducescatter_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uint16_and_reducescatter_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_and_reducescatter_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uint16_and_reducescatter_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uint16_and_reducescatter_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uint16_and_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_and_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_uint32_and_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uint32_and_reducescatter_blockiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_and_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uint32_and_reducescatter_blockiPjPKjm_nbst = declare_device(
        '_ZL39nvshmemx_uint32_and_reducescatter_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uint32_and_reducescatter_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uint32_and_reducescatter_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_and_reducescatter_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uint32_and_reducescatter_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uint32_and_reducescatter_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uint32_and_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_and_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_uint64_and_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uint64_and_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_and_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uint64_and_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL39nvshmemx_uint64_and_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uint64_and_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uint64_and_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_and_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uint64_and_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uint64_and_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uint64_and_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def size_and_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_size_and_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_size_and_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_and_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_size_and_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL37nvshmemx_size_and_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_size_and_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_size_and_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_and_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_size_and_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_size_and_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_size_and_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def uchar_or_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_uchar_or_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uchar_or_reducescatter_blockiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_or_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uchar_or_reducescatter_blockiPhPKhm_nbst = declare_device(
        '_ZL37nvshmemx_uchar_or_reducescatter_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uchar_or_reducescatter_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uchar_or_reducescatter_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_or_reducescatter_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uchar_or_reducescatter_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uchar_or_reducescatter_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uchar_or_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_or_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_ushort_or_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_ushort_or_reducescatter_blockiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_or_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_ushort_or_reducescatter_blockiPtPKtm_nbst = declare_device(
        '_ZL38nvshmemx_ushort_or_reducescatter_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_ushort_or_reducescatter_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_ushort_or_reducescatter_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_or_reducescatter_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_ushort_or_reducescatter_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_ushort_or_reducescatter_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_ushort_or_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint_or_reducescatter_block():
    pass
    

def _lower__ZL36nvshmemx_uint_or_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_uint_or_reducescatter_blockiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_or_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_uint_or_reducescatter_blockiPjPKjm_nbst = declare_device(
        '_ZL36nvshmemx_uint_or_reducescatter_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_uint_or_reducescatter_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_uint_or_reducescatter_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_or_reducescatter_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_uint_or_reducescatter_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_uint_or_reducescatter_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_uint_or_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_or_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_ulong_or_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_ulong_or_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_or_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_ulong_or_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL37nvshmemx_ulong_or_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_ulong_or_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_ulong_or_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_or_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_ulong_or_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_ulong_or_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_ulong_or_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_or_reducescatter_block():
    pass
    

def _lower__ZL41nvshmemx_ulonglong_or_reducescatter_blockiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL41nvshmemx_ulonglong_or_reducescatter_blockiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_or_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL41nvshmemx_ulonglong_or_reducescatter_blockiPyPKym_nbst = declare_device(
        '_ZL41nvshmemx_ulonglong_or_reducescatter_blockiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL41nvshmemx_ulonglong_or_reducescatter_blockiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL41nvshmemx_ulonglong_or_reducescatter_blockiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_or_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL41nvshmemx_ulonglong_or_reducescatter_blockiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL41nvshmemx_ulonglong_or_reducescatter_blockiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL41nvshmemx_ulonglong_or_reducescatter_blockiPyPKym_nbst(shim_stream, shim_obj)


def int8_or_reducescatter_block():
    pass
    

def _lower__ZL36nvshmemx_int8_or_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_int8_or_reducescatter_blockiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_or_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_int8_or_reducescatter_blockiPaPKam_nbst = declare_device(
        '_ZL36nvshmemx_int8_or_reducescatter_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_int8_or_reducescatter_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_int8_or_reducescatter_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_or_reducescatter_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_int8_or_reducescatter_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_int8_or_reducescatter_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_int8_or_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj)


def int16_or_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_int16_or_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int16_or_reducescatter_blockiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_or_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int16_or_reducescatter_blockiPsPKsm_nbst = declare_device(
        '_ZL37nvshmemx_int16_or_reducescatter_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int16_or_reducescatter_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int16_or_reducescatter_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_or_reducescatter_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int16_or_reducescatter_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int16_or_reducescatter_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int16_or_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int32_or_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_int32_or_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int32_or_reducescatter_blockiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_or_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int32_or_reducescatter_blockiPiPKim_nbst = declare_device(
        '_ZL37nvshmemx_int32_or_reducescatter_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int32_or_reducescatter_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int32_or_reducescatter_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_or_reducescatter_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int32_or_reducescatter_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int32_or_reducescatter_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int32_or_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj)


def int64_or_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_int64_or_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int64_or_reducescatter_blockiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_or_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int64_or_reducescatter_blockiPlPKlm_nbst = declare_device(
        '_ZL37nvshmemx_int64_or_reducescatter_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int64_or_reducescatter_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int64_or_reducescatter_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_or_reducescatter_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int64_or_reducescatter_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int64_or_reducescatter_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int64_or_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_or_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_uint8_or_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uint8_or_reducescatter_blockiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_or_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uint8_or_reducescatter_blockiPhPKhm_nbst = declare_device(
        '_ZL37nvshmemx_uint8_or_reducescatter_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uint8_or_reducescatter_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uint8_or_reducescatter_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_or_reducescatter_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uint8_or_reducescatter_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uint8_or_reducescatter_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uint8_or_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_or_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_uint16_or_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint16_or_reducescatter_blockiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_or_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint16_or_reducescatter_blockiPtPKtm_nbst = declare_device(
        '_ZL38nvshmemx_uint16_or_reducescatter_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint16_or_reducescatter_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint16_or_reducescatter_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_or_reducescatter_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint16_or_reducescatter_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint16_or_reducescatter_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint16_or_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_or_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_uint32_or_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint32_or_reducescatter_blockiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_or_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint32_or_reducescatter_blockiPjPKjm_nbst = declare_device(
        '_ZL38nvshmemx_uint32_or_reducescatter_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint32_or_reducescatter_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint32_or_reducescatter_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_or_reducescatter_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint32_or_reducescatter_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint32_or_reducescatter_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint32_or_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_or_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_uint64_or_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint64_or_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_or_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint64_or_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL38nvshmemx_uint64_or_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint64_or_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint64_or_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_or_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint64_or_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint64_or_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint64_or_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def size_or_reducescatter_block():
    pass
    

def _lower__ZL36nvshmemx_size_or_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_size_or_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_or_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_size_or_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL36nvshmemx_size_or_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_size_or_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_size_or_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_or_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_size_or_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_size_or_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_size_or_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def uchar_xor_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_uchar_xor_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uchar_xor_reducescatter_blockiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_xor_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uchar_xor_reducescatter_blockiPhPKhm_nbst = declare_device(
        '_ZL38nvshmemx_uchar_xor_reducescatter_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uchar_xor_reducescatter_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uchar_xor_reducescatter_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_xor_reducescatter_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uchar_xor_reducescatter_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uchar_xor_reducescatter_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uchar_xor_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_xor_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_ushort_xor_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_ushort_xor_reducescatter_blockiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_xor_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_ushort_xor_reducescatter_blockiPtPKtm_nbst = declare_device(
        '_ZL39nvshmemx_ushort_xor_reducescatter_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_ushort_xor_reducescatter_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_ushort_xor_reducescatter_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_xor_reducescatter_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_ushort_xor_reducescatter_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_ushort_xor_reducescatter_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_ushort_xor_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint_xor_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_uint_xor_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uint_xor_reducescatter_blockiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_xor_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uint_xor_reducescatter_blockiPjPKjm_nbst = declare_device(
        '_ZL37nvshmemx_uint_xor_reducescatter_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uint_xor_reducescatter_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uint_xor_reducescatter_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_xor_reducescatter_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uint_xor_reducescatter_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uint_xor_reducescatter_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uint_xor_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_xor_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_ulong_xor_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_ulong_xor_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_xor_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_ulong_xor_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL38nvshmemx_ulong_xor_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_ulong_xor_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_ulong_xor_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_xor_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_ulong_xor_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_ulong_xor_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_ulong_xor_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_xor_reducescatter_block():
    pass
    

def _lower__ZL42nvshmemx_ulonglong_xor_reducescatter_blockiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL42nvshmemx_ulonglong_xor_reducescatter_blockiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_xor_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL42nvshmemx_ulonglong_xor_reducescatter_blockiPyPKym_nbst = declare_device(
        '_ZL42nvshmemx_ulonglong_xor_reducescatter_blockiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL42nvshmemx_ulonglong_xor_reducescatter_blockiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL42nvshmemx_ulonglong_xor_reducescatter_blockiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_xor_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL42nvshmemx_ulonglong_xor_reducescatter_blockiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL42nvshmemx_ulonglong_xor_reducescatter_blockiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL42nvshmemx_ulonglong_xor_reducescatter_blockiPyPKym_nbst(shim_stream, shim_obj)


def int8_xor_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_int8_xor_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int8_xor_reducescatter_blockiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_xor_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int8_xor_reducescatter_blockiPaPKam_nbst = declare_device(
        '_ZL37nvshmemx_int8_xor_reducescatter_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int8_xor_reducescatter_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int8_xor_reducescatter_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_xor_reducescatter_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int8_xor_reducescatter_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int8_xor_reducescatter_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int8_xor_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj)


def int16_xor_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_int16_xor_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_int16_xor_reducescatter_blockiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_xor_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_int16_xor_reducescatter_blockiPsPKsm_nbst = declare_device(
        '_ZL38nvshmemx_int16_xor_reducescatter_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_int16_xor_reducescatter_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_int16_xor_reducescatter_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_xor_reducescatter_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_int16_xor_reducescatter_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_int16_xor_reducescatter_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_int16_xor_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int32_xor_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_int32_xor_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_int32_xor_reducescatter_blockiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_xor_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_int32_xor_reducescatter_blockiPiPKim_nbst = declare_device(
        '_ZL38nvshmemx_int32_xor_reducescatter_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_int32_xor_reducescatter_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_int32_xor_reducescatter_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_xor_reducescatter_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_int32_xor_reducescatter_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_int32_xor_reducescatter_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_int32_xor_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj)


def int64_xor_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_int64_xor_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_int64_xor_reducescatter_blockiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_xor_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_int64_xor_reducescatter_blockiPlPKlm_nbst = declare_device(
        '_ZL38nvshmemx_int64_xor_reducescatter_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_int64_xor_reducescatter_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_int64_xor_reducescatter_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_xor_reducescatter_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_int64_xor_reducescatter_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_int64_xor_reducescatter_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_int64_xor_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_xor_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_uint8_xor_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint8_xor_reducescatter_blockiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_xor_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint8_xor_reducescatter_blockiPhPKhm_nbst = declare_device(
        '_ZL38nvshmemx_uint8_xor_reducescatter_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint8_xor_reducescatter_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint8_xor_reducescatter_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_xor_reducescatter_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint8_xor_reducescatter_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint8_xor_reducescatter_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint8_xor_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_xor_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_uint16_xor_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uint16_xor_reducescatter_blockiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_xor_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uint16_xor_reducescatter_blockiPtPKtm_nbst = declare_device(
        '_ZL39nvshmemx_uint16_xor_reducescatter_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uint16_xor_reducescatter_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uint16_xor_reducescatter_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_xor_reducescatter_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uint16_xor_reducescatter_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uint16_xor_reducescatter_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uint16_xor_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_xor_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_uint32_xor_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uint32_xor_reducescatter_blockiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_xor_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uint32_xor_reducescatter_blockiPjPKjm_nbst = declare_device(
        '_ZL39nvshmemx_uint32_xor_reducescatter_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uint32_xor_reducescatter_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uint32_xor_reducescatter_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_xor_reducescatter_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uint32_xor_reducescatter_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uint32_xor_reducescatter_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uint32_xor_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_xor_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_uint64_xor_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uint64_xor_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_xor_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uint64_xor_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL39nvshmemx_uint64_xor_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uint64_xor_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uint64_xor_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_xor_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uint64_xor_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uint64_xor_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uint64_xor_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def size_xor_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_size_xor_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_size_xor_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_xor_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_size_xor_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL37nvshmemx_size_xor_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_size_xor_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_size_xor_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_xor_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_size_xor_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_size_xor_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_size_xor_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def uchar_max_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_uchar_max_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uchar_max_reducescatter_blockiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uchar_max_reducescatter_blockiPhPKhm_nbst = declare_device(
        '_ZL38nvshmemx_uchar_max_reducescatter_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uchar_max_reducescatter_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uchar_max_reducescatter_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_max_reducescatter_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uchar_max_reducescatter_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uchar_max_reducescatter_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uchar_max_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_max_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_ushort_max_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_ushort_max_reducescatter_blockiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_ushort_max_reducescatter_blockiPtPKtm_nbst = declare_device(
        '_ZL39nvshmemx_ushort_max_reducescatter_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_ushort_max_reducescatter_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_ushort_max_reducescatter_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_max_reducescatter_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_ushort_max_reducescatter_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_ushort_max_reducescatter_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_ushort_max_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint_max_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_uint_max_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uint_max_reducescatter_blockiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uint_max_reducescatter_blockiPjPKjm_nbst = declare_device(
        '_ZL37nvshmemx_uint_max_reducescatter_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uint_max_reducescatter_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uint_max_reducescatter_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_max_reducescatter_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uint_max_reducescatter_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uint_max_reducescatter_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uint_max_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_max_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_ulong_max_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_ulong_max_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_ulong_max_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL38nvshmemx_ulong_max_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_ulong_max_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_ulong_max_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_max_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_ulong_max_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_ulong_max_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_ulong_max_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_max_reducescatter_block():
    pass
    

def _lower__ZL42nvshmemx_ulonglong_max_reducescatter_blockiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL42nvshmemx_ulonglong_max_reducescatter_blockiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL42nvshmemx_ulonglong_max_reducescatter_blockiPyPKym_nbst = declare_device(
        '_ZL42nvshmemx_ulonglong_max_reducescatter_blockiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL42nvshmemx_ulonglong_max_reducescatter_blockiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL42nvshmemx_ulonglong_max_reducescatter_blockiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_max_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL42nvshmemx_ulonglong_max_reducescatter_blockiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL42nvshmemx_ulonglong_max_reducescatter_blockiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL42nvshmemx_ulonglong_max_reducescatter_blockiPyPKym_nbst(shim_stream, shim_obj)


def int8_max_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_int8_max_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int8_max_reducescatter_blockiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int8_max_reducescatter_blockiPaPKam_nbst = declare_device(
        '_ZL37nvshmemx_int8_max_reducescatter_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int8_max_reducescatter_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int8_max_reducescatter_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_max_reducescatter_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int8_max_reducescatter_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int8_max_reducescatter_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int8_max_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj)


def int16_max_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_int16_max_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_int16_max_reducescatter_blockiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_int16_max_reducescatter_blockiPsPKsm_nbst = declare_device(
        '_ZL38nvshmemx_int16_max_reducescatter_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_int16_max_reducescatter_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_int16_max_reducescatter_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_max_reducescatter_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_int16_max_reducescatter_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_int16_max_reducescatter_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_int16_max_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int32_max_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_int32_max_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_int32_max_reducescatter_blockiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_int32_max_reducescatter_blockiPiPKim_nbst = declare_device(
        '_ZL38nvshmemx_int32_max_reducescatter_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_int32_max_reducescatter_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_int32_max_reducescatter_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_max_reducescatter_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_int32_max_reducescatter_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_int32_max_reducescatter_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_int32_max_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj)


def int64_max_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_int64_max_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_int64_max_reducescatter_blockiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_int64_max_reducescatter_blockiPlPKlm_nbst = declare_device(
        '_ZL38nvshmemx_int64_max_reducescatter_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_int64_max_reducescatter_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_int64_max_reducescatter_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_max_reducescatter_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_int64_max_reducescatter_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_int64_max_reducescatter_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_int64_max_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_max_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_uint8_max_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint8_max_reducescatter_blockiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint8_max_reducescatter_blockiPhPKhm_nbst = declare_device(
        '_ZL38nvshmemx_uint8_max_reducescatter_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint8_max_reducescatter_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint8_max_reducescatter_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_max_reducescatter_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint8_max_reducescatter_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint8_max_reducescatter_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint8_max_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_max_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_uint16_max_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uint16_max_reducescatter_blockiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uint16_max_reducescatter_blockiPtPKtm_nbst = declare_device(
        '_ZL39nvshmemx_uint16_max_reducescatter_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uint16_max_reducescatter_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uint16_max_reducescatter_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_max_reducescatter_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uint16_max_reducescatter_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uint16_max_reducescatter_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uint16_max_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_max_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_uint32_max_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uint32_max_reducescatter_blockiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uint32_max_reducescatter_blockiPjPKjm_nbst = declare_device(
        '_ZL39nvshmemx_uint32_max_reducescatter_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uint32_max_reducescatter_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uint32_max_reducescatter_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_max_reducescatter_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uint32_max_reducescatter_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uint32_max_reducescatter_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uint32_max_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_max_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_uint64_max_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uint64_max_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uint64_max_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL39nvshmemx_uint64_max_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uint64_max_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uint64_max_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_max_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uint64_max_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uint64_max_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uint64_max_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def size_max_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_size_max_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_size_max_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_size_max_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL37nvshmemx_size_max_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_size_max_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_size_max_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_max_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_size_max_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_size_max_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_size_max_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def char_max_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_char_max_reducescatter_blockiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_char_max_reducescatter_blockiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmemx_char_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_char_max_reducescatter_blockiPcPKcm_nbst = declare_device(
        '_ZL37nvshmemx_char_max_reducescatter_blockiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_char_max_reducescatter_blockiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_char_max_reducescatter_blockiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_max_reducescatter_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_char_max_reducescatter_blockiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_char_max_reducescatter_blockiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_char_max_reducescatter_blockiPcPKcm_nbst(shim_stream, shim_obj)


def schar_max_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_schar_max_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_schar_max_reducescatter_blockiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmemx_schar_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_schar_max_reducescatter_blockiPaPKam_nbst = declare_device(
        '_ZL38nvshmemx_schar_max_reducescatter_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_schar_max_reducescatter_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_schar_max_reducescatter_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_max_reducescatter_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_schar_max_reducescatter_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_schar_max_reducescatter_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_schar_max_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj)


def short_max_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_short_max_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_short_max_reducescatter_blockiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmemx_short_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_short_max_reducescatter_blockiPsPKsm_nbst = declare_device(
        '_ZL38nvshmemx_short_max_reducescatter_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_short_max_reducescatter_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_short_max_reducescatter_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_max_reducescatter_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_short_max_reducescatter_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_short_max_reducescatter_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_short_max_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int_max_reducescatter_block():
    pass
    

def _lower__ZL36nvshmemx_int_max_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_int_max_reducescatter_blockiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmemx_int_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_int_max_reducescatter_blockiPiPKim_nbst = declare_device(
        '_ZL36nvshmemx_int_max_reducescatter_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_int_max_reducescatter_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_int_max_reducescatter_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_max_reducescatter_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_int_max_reducescatter_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_int_max_reducescatter_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_int_max_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj)


def long_max_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_long_max_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_long_max_reducescatter_blockiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmemx_long_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_long_max_reducescatter_blockiPlPKlm_nbst = declare_device(
        '_ZL37nvshmemx_long_max_reducescatter_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_long_max_reducescatter_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_long_max_reducescatter_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_max_reducescatter_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_long_max_reducescatter_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_long_max_reducescatter_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_long_max_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_max_reducescatter_block():
    pass
    

def _lower__ZL41nvshmemx_longlong_max_reducescatter_blockiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL41nvshmemx_longlong_max_reducescatter_blockiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_longlong_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL41nvshmemx_longlong_max_reducescatter_blockiPxPKxm_nbst = declare_device(
        '_ZL41nvshmemx_longlong_max_reducescatter_blockiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL41nvshmemx_longlong_max_reducescatter_blockiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL41nvshmemx_longlong_max_reducescatter_blockiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_max_reducescatter_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL41nvshmemx_longlong_max_reducescatter_blockiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL41nvshmemx_longlong_max_reducescatter_blockiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL41nvshmemx_longlong_max_reducescatter_blockiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_max_reducescatter_block():
    pass
    

def _lower__ZL41nvshmemx_bfloat16_max_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL41nvshmemx_bfloat16_max_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmemx_bfloat16_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL41nvshmemx_bfloat16_max_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL41nvshmemx_bfloat16_max_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL41nvshmemx_bfloat16_max_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL41nvshmemx_bfloat16_max_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_max_reducescatter_block, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL41nvshmemx_bfloat16_max_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL41nvshmemx_bfloat16_max_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL41nvshmemx_bfloat16_max_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_max_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_half_max_reducescatter_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_half_max_reducescatter_blockiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmemx_half_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_half_max_reducescatter_blockiP6__halfPKS_m_nbst = declare_device(
        '_ZL37nvshmemx_half_max_reducescatter_blockiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_half_max_reducescatter_blockiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_half_max_reducescatter_blockiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_max_reducescatter_block, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_half_max_reducescatter_blockiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_half_max_reducescatter_blockiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_half_max_reducescatter_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_max_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_float_max_reducescatter_blockiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_float_max_reducescatter_blockiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmemx_float_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_float_max_reducescatter_blockiPfPKfm_nbst = declare_device(
        '_ZL38nvshmemx_float_max_reducescatter_blockiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_float_max_reducescatter_blockiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_float_max_reducescatter_blockiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_max_reducescatter_block, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_float_max_reducescatter_blockiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_float_max_reducescatter_blockiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_float_max_reducescatter_blockiPfPKfm_nbst(shim_stream, shim_obj)


def double_max_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_double_max_reducescatter_blockiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_double_max_reducescatter_blockiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmemx_double_max_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_double_max_reducescatter_blockiPdPKdm_nbst = declare_device(
        '_ZL39nvshmemx_double_max_reducescatter_blockiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_double_max_reducescatter_blockiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_double_max_reducescatter_blockiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_max_reducescatter_block, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_double_max_reducescatter_blockiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_double_max_reducescatter_blockiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_double_max_reducescatter_blockiPdPKdm_nbst(shim_stream, shim_obj)


def uchar_min_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_uchar_min_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uchar_min_reducescatter_blockiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uchar_min_reducescatter_blockiPhPKhm_nbst = declare_device(
        '_ZL38nvshmemx_uchar_min_reducescatter_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uchar_min_reducescatter_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uchar_min_reducescatter_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_min_reducescatter_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uchar_min_reducescatter_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uchar_min_reducescatter_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uchar_min_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_min_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_ushort_min_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_ushort_min_reducescatter_blockiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_ushort_min_reducescatter_blockiPtPKtm_nbst = declare_device(
        '_ZL39nvshmemx_ushort_min_reducescatter_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_ushort_min_reducescatter_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_ushort_min_reducescatter_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_min_reducescatter_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_ushort_min_reducescatter_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_ushort_min_reducescatter_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_ushort_min_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint_min_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_uint_min_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uint_min_reducescatter_blockiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uint_min_reducescatter_blockiPjPKjm_nbst = declare_device(
        '_ZL37nvshmemx_uint_min_reducescatter_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uint_min_reducescatter_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uint_min_reducescatter_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_min_reducescatter_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uint_min_reducescatter_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uint_min_reducescatter_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uint_min_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_min_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_ulong_min_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_ulong_min_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_ulong_min_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL38nvshmemx_ulong_min_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_ulong_min_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_ulong_min_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_min_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_ulong_min_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_ulong_min_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_ulong_min_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_min_reducescatter_block():
    pass
    

def _lower__ZL42nvshmemx_ulonglong_min_reducescatter_blockiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL42nvshmemx_ulonglong_min_reducescatter_blockiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL42nvshmemx_ulonglong_min_reducescatter_blockiPyPKym_nbst = declare_device(
        '_ZL42nvshmemx_ulonglong_min_reducescatter_blockiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL42nvshmemx_ulonglong_min_reducescatter_blockiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL42nvshmemx_ulonglong_min_reducescatter_blockiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_min_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL42nvshmemx_ulonglong_min_reducescatter_blockiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL42nvshmemx_ulonglong_min_reducescatter_blockiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL42nvshmemx_ulonglong_min_reducescatter_blockiPyPKym_nbst(shim_stream, shim_obj)


def int8_min_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_int8_min_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int8_min_reducescatter_blockiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int8_min_reducescatter_blockiPaPKam_nbst = declare_device(
        '_ZL37nvshmemx_int8_min_reducescatter_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int8_min_reducescatter_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int8_min_reducescatter_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_min_reducescatter_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int8_min_reducescatter_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int8_min_reducescatter_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int8_min_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj)


def int16_min_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_int16_min_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_int16_min_reducescatter_blockiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_int16_min_reducescatter_blockiPsPKsm_nbst = declare_device(
        '_ZL38nvshmemx_int16_min_reducescatter_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_int16_min_reducescatter_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_int16_min_reducescatter_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_min_reducescatter_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_int16_min_reducescatter_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_int16_min_reducescatter_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_int16_min_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int32_min_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_int32_min_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_int32_min_reducescatter_blockiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_int32_min_reducescatter_blockiPiPKim_nbst = declare_device(
        '_ZL38nvshmemx_int32_min_reducescatter_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_int32_min_reducescatter_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_int32_min_reducescatter_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_min_reducescatter_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_int32_min_reducescatter_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_int32_min_reducescatter_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_int32_min_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj)


def int64_min_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_int64_min_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_int64_min_reducescatter_blockiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_int64_min_reducescatter_blockiPlPKlm_nbst = declare_device(
        '_ZL38nvshmemx_int64_min_reducescatter_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_int64_min_reducescatter_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_int64_min_reducescatter_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_min_reducescatter_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_int64_min_reducescatter_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_int64_min_reducescatter_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_int64_min_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_min_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_uint8_min_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint8_min_reducescatter_blockiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint8_min_reducescatter_blockiPhPKhm_nbst = declare_device(
        '_ZL38nvshmemx_uint8_min_reducescatter_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint8_min_reducescatter_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint8_min_reducescatter_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_min_reducescatter_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint8_min_reducescatter_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint8_min_reducescatter_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint8_min_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_min_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_uint16_min_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uint16_min_reducescatter_blockiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uint16_min_reducescatter_blockiPtPKtm_nbst = declare_device(
        '_ZL39nvshmemx_uint16_min_reducescatter_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uint16_min_reducescatter_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uint16_min_reducescatter_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_min_reducescatter_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uint16_min_reducescatter_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uint16_min_reducescatter_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uint16_min_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_min_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_uint32_min_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uint32_min_reducescatter_blockiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uint32_min_reducescatter_blockiPjPKjm_nbst = declare_device(
        '_ZL39nvshmemx_uint32_min_reducescatter_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uint32_min_reducescatter_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uint32_min_reducescatter_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_min_reducescatter_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uint32_min_reducescatter_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uint32_min_reducescatter_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uint32_min_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_min_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_uint64_min_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uint64_min_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uint64_min_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL39nvshmemx_uint64_min_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uint64_min_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uint64_min_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_min_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uint64_min_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uint64_min_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uint64_min_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def size_min_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_size_min_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_size_min_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_size_min_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL37nvshmemx_size_min_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_size_min_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_size_min_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_min_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_size_min_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_size_min_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_size_min_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def char_min_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_char_min_reducescatter_blockiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_char_min_reducescatter_blockiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmemx_char_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_char_min_reducescatter_blockiPcPKcm_nbst = declare_device(
        '_ZL37nvshmemx_char_min_reducescatter_blockiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_char_min_reducescatter_blockiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_char_min_reducescatter_blockiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_min_reducescatter_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_char_min_reducescatter_blockiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_char_min_reducescatter_blockiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_char_min_reducescatter_blockiPcPKcm_nbst(shim_stream, shim_obj)


def schar_min_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_schar_min_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_schar_min_reducescatter_blockiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmemx_schar_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_schar_min_reducescatter_blockiPaPKam_nbst = declare_device(
        '_ZL38nvshmemx_schar_min_reducescatter_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_schar_min_reducescatter_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_schar_min_reducescatter_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_min_reducescatter_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_schar_min_reducescatter_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_schar_min_reducescatter_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_schar_min_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj)


def short_min_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_short_min_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_short_min_reducescatter_blockiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmemx_short_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_short_min_reducescatter_blockiPsPKsm_nbst = declare_device(
        '_ZL38nvshmemx_short_min_reducescatter_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_short_min_reducescatter_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_short_min_reducescatter_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_min_reducescatter_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_short_min_reducescatter_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_short_min_reducescatter_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_short_min_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int_min_reducescatter_block():
    pass
    

def _lower__ZL36nvshmemx_int_min_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_int_min_reducescatter_blockiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmemx_int_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_int_min_reducescatter_blockiPiPKim_nbst = declare_device(
        '_ZL36nvshmemx_int_min_reducescatter_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_int_min_reducescatter_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_int_min_reducescatter_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_min_reducescatter_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_int_min_reducescatter_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_int_min_reducescatter_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_int_min_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj)


def long_min_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_long_min_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_long_min_reducescatter_blockiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmemx_long_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_long_min_reducescatter_blockiPlPKlm_nbst = declare_device(
        '_ZL37nvshmemx_long_min_reducescatter_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_long_min_reducescatter_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_long_min_reducescatter_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_min_reducescatter_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_long_min_reducescatter_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_long_min_reducescatter_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_long_min_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_min_reducescatter_block():
    pass
    

def _lower__ZL41nvshmemx_longlong_min_reducescatter_blockiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL41nvshmemx_longlong_min_reducescatter_blockiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_longlong_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL41nvshmemx_longlong_min_reducescatter_blockiPxPKxm_nbst = declare_device(
        '_ZL41nvshmemx_longlong_min_reducescatter_blockiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL41nvshmemx_longlong_min_reducescatter_blockiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL41nvshmemx_longlong_min_reducescatter_blockiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_min_reducescatter_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL41nvshmemx_longlong_min_reducescatter_blockiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL41nvshmemx_longlong_min_reducescatter_blockiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL41nvshmemx_longlong_min_reducescatter_blockiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_min_reducescatter_block():
    pass
    

def _lower__ZL41nvshmemx_bfloat16_min_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL41nvshmemx_bfloat16_min_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmemx_bfloat16_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL41nvshmemx_bfloat16_min_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL41nvshmemx_bfloat16_min_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL41nvshmemx_bfloat16_min_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL41nvshmemx_bfloat16_min_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_min_reducescatter_block, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL41nvshmemx_bfloat16_min_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL41nvshmemx_bfloat16_min_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL41nvshmemx_bfloat16_min_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_min_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_half_min_reducescatter_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_half_min_reducescatter_blockiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmemx_half_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_half_min_reducescatter_blockiP6__halfPKS_m_nbst = declare_device(
        '_ZL37nvshmemx_half_min_reducescatter_blockiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_half_min_reducescatter_blockiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_half_min_reducescatter_blockiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_min_reducescatter_block, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_half_min_reducescatter_blockiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_half_min_reducescatter_blockiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_half_min_reducescatter_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_min_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_float_min_reducescatter_blockiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_float_min_reducescatter_blockiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmemx_float_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_float_min_reducescatter_blockiPfPKfm_nbst = declare_device(
        '_ZL38nvshmemx_float_min_reducescatter_blockiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_float_min_reducescatter_blockiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_float_min_reducescatter_blockiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_min_reducescatter_block, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_float_min_reducescatter_blockiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_float_min_reducescatter_blockiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_float_min_reducescatter_blockiPfPKfm_nbst(shim_stream, shim_obj)


def double_min_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_double_min_reducescatter_blockiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_double_min_reducescatter_blockiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmemx_double_min_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_double_min_reducescatter_blockiPdPKdm_nbst = declare_device(
        '_ZL39nvshmemx_double_min_reducescatter_blockiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_double_min_reducescatter_blockiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_double_min_reducescatter_blockiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_min_reducescatter_block, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_double_min_reducescatter_blockiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_double_min_reducescatter_blockiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_double_min_reducescatter_blockiPdPKdm_nbst(shim_stream, shim_obj)


def uchar_sum_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_uchar_sum_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uchar_sum_reducescatter_blockiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uchar_sum_reducescatter_blockiPhPKhm_nbst = declare_device(
        '_ZL38nvshmemx_uchar_sum_reducescatter_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uchar_sum_reducescatter_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uchar_sum_reducescatter_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_sum_reducescatter_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uchar_sum_reducescatter_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uchar_sum_reducescatter_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uchar_sum_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_sum_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_ushort_sum_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_ushort_sum_reducescatter_blockiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_ushort_sum_reducescatter_blockiPtPKtm_nbst = declare_device(
        '_ZL39nvshmemx_ushort_sum_reducescatter_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_ushort_sum_reducescatter_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_ushort_sum_reducescatter_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_sum_reducescatter_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_ushort_sum_reducescatter_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_ushort_sum_reducescatter_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_ushort_sum_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint_sum_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_uint_sum_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_uint_sum_reducescatter_blockiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_uint_sum_reducescatter_blockiPjPKjm_nbst = declare_device(
        '_ZL37nvshmemx_uint_sum_reducescatter_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_uint_sum_reducescatter_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_uint_sum_reducescatter_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_sum_reducescatter_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_uint_sum_reducescatter_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_uint_sum_reducescatter_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_uint_sum_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_sum_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_ulong_sum_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_ulong_sum_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_ulong_sum_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL38nvshmemx_ulong_sum_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_ulong_sum_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_ulong_sum_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_sum_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_ulong_sum_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_ulong_sum_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_ulong_sum_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_sum_reducescatter_block():
    pass
    

def _lower__ZL42nvshmemx_ulonglong_sum_reducescatter_blockiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL42nvshmemx_ulonglong_sum_reducescatter_blockiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL42nvshmemx_ulonglong_sum_reducescatter_blockiPyPKym_nbst = declare_device(
        '_ZL42nvshmemx_ulonglong_sum_reducescatter_blockiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL42nvshmemx_ulonglong_sum_reducescatter_blockiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL42nvshmemx_ulonglong_sum_reducescatter_blockiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_sum_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL42nvshmemx_ulonglong_sum_reducescatter_blockiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL42nvshmemx_ulonglong_sum_reducescatter_blockiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL42nvshmemx_ulonglong_sum_reducescatter_blockiPyPKym_nbst(shim_stream, shim_obj)


def int8_sum_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_int8_sum_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int8_sum_reducescatter_blockiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int8_sum_reducescatter_blockiPaPKam_nbst = declare_device(
        '_ZL37nvshmemx_int8_sum_reducescatter_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int8_sum_reducescatter_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int8_sum_reducescatter_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_sum_reducescatter_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int8_sum_reducescatter_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int8_sum_reducescatter_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int8_sum_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj)


def int16_sum_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_int16_sum_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_int16_sum_reducescatter_blockiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_int16_sum_reducescatter_blockiPsPKsm_nbst = declare_device(
        '_ZL38nvshmemx_int16_sum_reducescatter_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_int16_sum_reducescatter_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_int16_sum_reducescatter_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_sum_reducescatter_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_int16_sum_reducescatter_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_int16_sum_reducescatter_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_int16_sum_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int32_sum_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_int32_sum_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_int32_sum_reducescatter_blockiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_int32_sum_reducescatter_blockiPiPKim_nbst = declare_device(
        '_ZL38nvshmemx_int32_sum_reducescatter_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_int32_sum_reducescatter_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_int32_sum_reducescatter_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_sum_reducescatter_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_int32_sum_reducescatter_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_int32_sum_reducescatter_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_int32_sum_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj)


def int64_sum_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_int64_sum_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_int64_sum_reducescatter_blockiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_int64_sum_reducescatter_blockiPlPKlm_nbst = declare_device(
        '_ZL38nvshmemx_int64_sum_reducescatter_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_int64_sum_reducescatter_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_int64_sum_reducescatter_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_sum_reducescatter_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_int64_sum_reducescatter_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_int64_sum_reducescatter_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_int64_sum_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_sum_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_uint8_sum_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint8_sum_reducescatter_blockiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint8_sum_reducescatter_blockiPhPKhm_nbst = declare_device(
        '_ZL38nvshmemx_uint8_sum_reducescatter_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint8_sum_reducescatter_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint8_sum_reducescatter_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_sum_reducescatter_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint8_sum_reducescatter_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint8_sum_reducescatter_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint8_sum_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_sum_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_uint16_sum_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uint16_sum_reducescatter_blockiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uint16_sum_reducescatter_blockiPtPKtm_nbst = declare_device(
        '_ZL39nvshmemx_uint16_sum_reducescatter_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uint16_sum_reducescatter_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uint16_sum_reducescatter_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_sum_reducescatter_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uint16_sum_reducescatter_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uint16_sum_reducescatter_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uint16_sum_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_sum_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_uint32_sum_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uint32_sum_reducescatter_blockiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uint32_sum_reducescatter_blockiPjPKjm_nbst = declare_device(
        '_ZL39nvshmemx_uint32_sum_reducescatter_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uint32_sum_reducescatter_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uint32_sum_reducescatter_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_sum_reducescatter_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uint32_sum_reducescatter_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uint32_sum_reducescatter_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uint32_sum_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_sum_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_uint64_sum_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uint64_sum_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uint64_sum_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL39nvshmemx_uint64_sum_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uint64_sum_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uint64_sum_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_sum_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uint64_sum_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uint64_sum_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uint64_sum_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def size_sum_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_size_sum_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_size_sum_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_size_sum_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL37nvshmemx_size_sum_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_size_sum_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_size_sum_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_sum_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_size_sum_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_size_sum_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_size_sum_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def char_sum_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_char_sum_reducescatter_blockiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_char_sum_reducescatter_blockiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmemx_char_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_char_sum_reducescatter_blockiPcPKcm_nbst = declare_device(
        '_ZL37nvshmemx_char_sum_reducescatter_blockiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_char_sum_reducescatter_blockiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_char_sum_reducescatter_blockiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_sum_reducescatter_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_char_sum_reducescatter_blockiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_char_sum_reducescatter_blockiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_char_sum_reducescatter_blockiPcPKcm_nbst(shim_stream, shim_obj)


def schar_sum_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_schar_sum_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_schar_sum_reducescatter_blockiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmemx_schar_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_schar_sum_reducescatter_blockiPaPKam_nbst = declare_device(
        '_ZL38nvshmemx_schar_sum_reducescatter_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_schar_sum_reducescatter_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_schar_sum_reducescatter_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_sum_reducescatter_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_schar_sum_reducescatter_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_schar_sum_reducescatter_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_schar_sum_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj)


def short_sum_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_short_sum_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_short_sum_reducescatter_blockiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmemx_short_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_short_sum_reducescatter_blockiPsPKsm_nbst = declare_device(
        '_ZL38nvshmemx_short_sum_reducescatter_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_short_sum_reducescatter_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_short_sum_reducescatter_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_sum_reducescatter_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_short_sum_reducescatter_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_short_sum_reducescatter_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_short_sum_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int_sum_reducescatter_block():
    pass
    

def _lower__ZL36nvshmemx_int_sum_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_int_sum_reducescatter_blockiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmemx_int_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_int_sum_reducescatter_blockiPiPKim_nbst = declare_device(
        '_ZL36nvshmemx_int_sum_reducescatter_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_int_sum_reducescatter_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_int_sum_reducescatter_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_sum_reducescatter_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_int_sum_reducescatter_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_int_sum_reducescatter_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_int_sum_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj)


def long_sum_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_long_sum_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_long_sum_reducescatter_blockiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmemx_long_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_long_sum_reducescatter_blockiPlPKlm_nbst = declare_device(
        '_ZL37nvshmemx_long_sum_reducescatter_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_long_sum_reducescatter_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_long_sum_reducescatter_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_sum_reducescatter_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_long_sum_reducescatter_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_long_sum_reducescatter_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_long_sum_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_sum_reducescatter_block():
    pass
    

def _lower__ZL41nvshmemx_longlong_sum_reducescatter_blockiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL41nvshmemx_longlong_sum_reducescatter_blockiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_longlong_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL41nvshmemx_longlong_sum_reducescatter_blockiPxPKxm_nbst = declare_device(
        '_ZL41nvshmemx_longlong_sum_reducescatter_blockiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL41nvshmemx_longlong_sum_reducescatter_blockiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL41nvshmemx_longlong_sum_reducescatter_blockiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_sum_reducescatter_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL41nvshmemx_longlong_sum_reducescatter_blockiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL41nvshmemx_longlong_sum_reducescatter_blockiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL41nvshmemx_longlong_sum_reducescatter_blockiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_sum_reducescatter_block():
    pass
    

def _lower__ZL41nvshmemx_bfloat16_sum_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL41nvshmemx_bfloat16_sum_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmemx_bfloat16_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL41nvshmemx_bfloat16_sum_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL41nvshmemx_bfloat16_sum_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL41nvshmemx_bfloat16_sum_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL41nvshmemx_bfloat16_sum_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_sum_reducescatter_block, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL41nvshmemx_bfloat16_sum_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL41nvshmemx_bfloat16_sum_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL41nvshmemx_bfloat16_sum_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_sum_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_half_sum_reducescatter_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_half_sum_reducescatter_blockiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmemx_half_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_half_sum_reducescatter_blockiP6__halfPKS_m_nbst = declare_device(
        '_ZL37nvshmemx_half_sum_reducescatter_blockiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_half_sum_reducescatter_blockiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_half_sum_reducescatter_blockiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_sum_reducescatter_block, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_half_sum_reducescatter_blockiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_half_sum_reducescatter_blockiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_half_sum_reducescatter_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_sum_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_float_sum_reducescatter_blockiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_float_sum_reducescatter_blockiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmemx_float_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_float_sum_reducescatter_blockiPfPKfm_nbst = declare_device(
        '_ZL38nvshmemx_float_sum_reducescatter_blockiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_float_sum_reducescatter_blockiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_float_sum_reducescatter_blockiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_sum_reducescatter_block, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_float_sum_reducescatter_blockiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_float_sum_reducescatter_blockiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_float_sum_reducescatter_blockiPfPKfm_nbst(shim_stream, shim_obj)


def double_sum_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_double_sum_reducescatter_blockiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_double_sum_reducescatter_blockiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmemx_double_sum_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_double_sum_reducescatter_blockiPdPKdm_nbst = declare_device(
        '_ZL39nvshmemx_double_sum_reducescatter_blockiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_double_sum_reducescatter_blockiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_double_sum_reducescatter_blockiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_sum_reducescatter_block, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_double_sum_reducescatter_blockiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_double_sum_reducescatter_blockiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_double_sum_reducescatter_blockiPdPKdm_nbst(shim_stream, shim_obj)


def uchar_prod_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_uchar_prod_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uchar_prod_reducescatter_blockiPhPKhm_nbst(int &retval , int* team, unsigned char ** dest, unsigned char ** source, unsigned long* nreduce) {
        retval = nvshmemx_uchar_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uchar_prod_reducescatter_blockiPhPKhm_nbst = declare_device(
        '_ZL39nvshmemx_uchar_prod_reducescatter_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uchar_prod_reducescatter_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uchar_prod_reducescatter_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uchar_prod_reducescatter_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uchar_prod_reducescatter_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uchar_prod_reducescatter_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uchar_prod_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj)


def ushort_prod_reducescatter_block():
    pass
    

def _lower__ZL40nvshmemx_ushort_prod_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL40nvshmemx_ushort_prod_reducescatter_blockiPtPKtm_nbst(int &retval , int* team, unsigned short ** dest, unsigned short ** source, unsigned long* nreduce) {
        retval = nvshmemx_ushort_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL40nvshmemx_ushort_prod_reducescatter_blockiPtPKtm_nbst = declare_device(
        '_ZL40nvshmemx_ushort_prod_reducescatter_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL40nvshmemx_ushort_prod_reducescatter_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL40nvshmemx_ushort_prod_reducescatter_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ushort_prod_reducescatter_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL40nvshmemx_ushort_prod_reducescatter_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL40nvshmemx_ushort_prod_reducescatter_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL40nvshmemx_ushort_prod_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint_prod_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_uint_prod_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_uint_prod_reducescatter_blockiPjPKjm_nbst(int &retval , int* team, unsigned int ** dest, unsigned int ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_uint_prod_reducescatter_blockiPjPKjm_nbst = declare_device(
        '_ZL38nvshmemx_uint_prod_reducescatter_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_uint_prod_reducescatter_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_uint_prod_reducescatter_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint_prod_reducescatter_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_uint_prod_reducescatter_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_uint_prod_reducescatter_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_uint_prod_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj)


def ulong_prod_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_ulong_prod_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_ulong_prod_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulong_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_ulong_prod_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL39nvshmemx_ulong_prod_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_ulong_prod_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_ulong_prod_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulong_prod_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_ulong_prod_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_ulong_prod_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_ulong_prod_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def ulonglong_prod_reducescatter_block():
    pass
    

def _lower__ZL43nvshmemx_ulonglong_prod_reducescatter_blockiPyPKym_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL43nvshmemx_ulonglong_prod_reducescatter_blockiPyPKym_nbst(int &retval , int* team, unsigned long long ** dest, unsigned long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_ulonglong_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL43nvshmemx_ulonglong_prod_reducescatter_blockiPyPKym_nbst = declare_device(
        '_ZL43nvshmemx_ulonglong_prod_reducescatter_blockiPyPKym_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL43nvshmemx_ulonglong_prod_reducescatter_blockiPyPKym_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL43nvshmemx_ulonglong_prod_reducescatter_blockiPyPKym_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(ulonglong_prod_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL43nvshmemx_ulonglong_prod_reducescatter_blockiPyPKym_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL43nvshmemx_ulonglong_prod_reducescatter_blockiPyPKym_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL43nvshmemx_ulonglong_prod_reducescatter_blockiPyPKym_nbst(shim_stream, shim_obj)


def int8_prod_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_int8_prod_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_int8_prod_reducescatter_blockiPaPKam_nbst(int &retval , int* team, int8_t ** dest, int8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int8_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_int8_prod_reducescatter_blockiPaPKam_nbst = declare_device(
        '_ZL38nvshmemx_int8_prod_reducescatter_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_int8_prod_reducescatter_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_int8_prod_reducescatter_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int8_prod_reducescatter_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_int8_prod_reducescatter_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_int8_prod_reducescatter_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_int8_prod_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj)


def int16_prod_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_int16_prod_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_int16_prod_reducescatter_blockiPsPKsm_nbst(int &retval , int* team, int16_t ** dest, int16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int16_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_int16_prod_reducescatter_blockiPsPKsm_nbst = declare_device(
        '_ZL39nvshmemx_int16_prod_reducescatter_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_int16_prod_reducescatter_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_int16_prod_reducescatter_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int16_prod_reducescatter_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_int16_prod_reducescatter_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_int16_prod_reducescatter_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_int16_prod_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int32_prod_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_int32_prod_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_int32_prod_reducescatter_blockiPiPKim_nbst(int &retval , int* team, int32_t ** dest, int32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int32_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_int32_prod_reducescatter_blockiPiPKim_nbst = declare_device(
        '_ZL39nvshmemx_int32_prod_reducescatter_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_int32_prod_reducescatter_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_int32_prod_reducescatter_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int32_prod_reducescatter_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_int32_prod_reducescatter_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_int32_prod_reducescatter_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_int32_prod_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj)


def int64_prod_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_int64_prod_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_int64_prod_reducescatter_blockiPlPKlm_nbst(int &retval , int* team, int64_t ** dest, int64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_int64_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_int64_prod_reducescatter_blockiPlPKlm_nbst = declare_device(
        '_ZL39nvshmemx_int64_prod_reducescatter_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_int64_prod_reducescatter_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_int64_prod_reducescatter_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int64_prod_reducescatter_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_int64_prod_reducescatter_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_int64_prod_reducescatter_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_int64_prod_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj)


def uint8_prod_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_uint8_prod_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_uint8_prod_reducescatter_blockiPhPKhm_nbst(int &retval , int* team, uint8_t ** dest, uint8_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint8_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_uint8_prod_reducescatter_blockiPhPKhm_nbst = declare_device(
        '_ZL39nvshmemx_uint8_prod_reducescatter_blockiPhPKhm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_uint8_prod_reducescatter_blockiPhPKhm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_uint8_prod_reducescatter_blockiPhPKhm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint8_prod_reducescatter_block, int32, CPointer(uint8), CPointer(uint8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_uint8_prod_reducescatter_blockiPhPKhm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_uint8_prod_reducescatter_blockiPhPKhm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint8)), CPointer(CPointer(uint8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_uint8_prod_reducescatter_blockiPhPKhm_nbst(shim_stream, shim_obj)


def uint16_prod_reducescatter_block():
    pass
    

def _lower__ZL40nvshmemx_uint16_prod_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL40nvshmemx_uint16_prod_reducescatter_blockiPtPKtm_nbst(int &retval , int* team, uint16_t ** dest, uint16_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint16_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL40nvshmemx_uint16_prod_reducescatter_blockiPtPKtm_nbst = declare_device(
        '_ZL40nvshmemx_uint16_prod_reducescatter_blockiPtPKtm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)
        )
    )
    

    def _ZL40nvshmemx_uint16_prod_reducescatter_blockiPtPKtm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL40nvshmemx_uint16_prod_reducescatter_blockiPtPKtm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint16_prod_reducescatter_block, int32, CPointer(uint16), CPointer(uint16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL40nvshmemx_uint16_prod_reducescatter_blockiPtPKtm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL40nvshmemx_uint16_prod_reducescatter_blockiPtPKtm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint16)), CPointer(CPointer(uint16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL40nvshmemx_uint16_prod_reducescatter_blockiPtPKtm_nbst(shim_stream, shim_obj)


def uint32_prod_reducescatter_block():
    pass
    

def _lower__ZL40nvshmemx_uint32_prod_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL40nvshmemx_uint32_prod_reducescatter_blockiPjPKjm_nbst(int &retval , int* team, uint32_t ** dest, uint32_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint32_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL40nvshmemx_uint32_prod_reducescatter_blockiPjPKjm_nbst = declare_device(
        '_ZL40nvshmemx_uint32_prod_reducescatter_blockiPjPKjm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)
        )
    )
    

    def _ZL40nvshmemx_uint32_prod_reducescatter_blockiPjPKjm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL40nvshmemx_uint32_prod_reducescatter_blockiPjPKjm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint32_prod_reducescatter_block, int32, CPointer(uint32), CPointer(uint32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL40nvshmemx_uint32_prod_reducescatter_blockiPjPKjm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL40nvshmemx_uint32_prod_reducescatter_blockiPjPKjm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint32)), CPointer(CPointer(uint32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL40nvshmemx_uint32_prod_reducescatter_blockiPjPKjm_nbst(shim_stream, shim_obj)


def uint64_prod_reducescatter_block():
    pass
    

def _lower__ZL40nvshmemx_uint64_prod_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL40nvshmemx_uint64_prod_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, uint64_t ** dest, uint64_t ** source, unsigned long* nreduce) {
        retval = nvshmemx_uint64_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL40nvshmemx_uint64_prod_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL40nvshmemx_uint64_prod_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL40nvshmemx_uint64_prod_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL40nvshmemx_uint64_prod_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(uint64_prod_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL40nvshmemx_uint64_prod_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL40nvshmemx_uint64_prod_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL40nvshmemx_uint64_prod_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def size_prod_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_size_prod_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_size_prod_reducescatter_blockiPmPKmm_nbst(int &retval , int* team, unsigned long ** dest, unsigned long ** source, unsigned long* nreduce) {
        retval = nvshmemx_size_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_size_prod_reducescatter_blockiPmPKmm_nbst = declare_device(
        '_ZL38nvshmemx_size_prod_reducescatter_blockiPmPKmm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_size_prod_reducescatter_blockiPmPKmm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_size_prod_reducescatter_blockiPmPKmm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(size_prod_reducescatter_block, int32, CPointer(uint64), CPointer(uint64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_size_prod_reducescatter_blockiPmPKmm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_size_prod_reducescatter_blockiPmPKmm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(uint64)), CPointer(CPointer(uint64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_size_prod_reducescatter_blockiPmPKmm_nbst(shim_stream, shim_obj)


def char_prod_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_char_prod_reducescatter_blockiPcPKcm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_char_prod_reducescatter_blockiPcPKcm_nbst(int &retval , int* team, char ** dest, char ** source, unsigned long* nreduce) {
        retval = nvshmemx_char_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_char_prod_reducescatter_blockiPcPKcm_nbst = declare_device(
        '_ZL38nvshmemx_char_prod_reducescatter_blockiPcPKcm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_char_prod_reducescatter_blockiPcPKcm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_char_prod_reducescatter_blockiPcPKcm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(char_prod_reducescatter_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_char_prod_reducescatter_blockiPcPKcm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_char_prod_reducescatter_blockiPcPKcm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_char_prod_reducescatter_blockiPcPKcm_nbst(shim_stream, shim_obj)


def schar_prod_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_schar_prod_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_schar_prod_reducescatter_blockiPaPKam_nbst(int &retval , int* team, signed char ** dest, signed char ** source, unsigned long* nreduce) {
        retval = nvshmemx_schar_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_schar_prod_reducescatter_blockiPaPKam_nbst = declare_device(
        '_ZL39nvshmemx_schar_prod_reducescatter_blockiPaPKam_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_schar_prod_reducescatter_blockiPaPKam_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_schar_prod_reducescatter_blockiPaPKam_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(schar_prod_reducescatter_block, int32, CPointer(int8), CPointer(int8), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_schar_prod_reducescatter_blockiPaPKam_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_schar_prod_reducescatter_blockiPaPKam_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int8)), CPointer(CPointer(int8)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_schar_prod_reducescatter_blockiPaPKam_nbst(shim_stream, shim_obj)


def short_prod_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_short_prod_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_short_prod_reducescatter_blockiPsPKsm_nbst(int &retval , int* team, short ** dest, short ** source, unsigned long* nreduce) {
        retval = nvshmemx_short_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_short_prod_reducescatter_blockiPsPKsm_nbst = declare_device(
        '_ZL39nvshmemx_short_prod_reducescatter_blockiPsPKsm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_short_prod_reducescatter_blockiPsPKsm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_short_prod_reducescatter_blockiPsPKsm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(short_prod_reducescatter_block, int32, CPointer(int16), CPointer(int16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_short_prod_reducescatter_blockiPsPKsm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_short_prod_reducescatter_blockiPsPKsm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int16)), CPointer(CPointer(int16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_short_prod_reducescatter_blockiPsPKsm_nbst(shim_stream, shim_obj)


def int_prod_reducescatter_block():
    pass
    

def _lower__ZL37nvshmemx_int_prod_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL37nvshmemx_int_prod_reducescatter_blockiPiPKim_nbst(int &retval , int* team, int ** dest, int ** source, unsigned long* nreduce) {
        retval = nvshmemx_int_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL37nvshmemx_int_prod_reducescatter_blockiPiPKim_nbst = declare_device(
        '_ZL37nvshmemx_int_prod_reducescatter_blockiPiPKim_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)
        )
    )
    

    def _ZL37nvshmemx_int_prod_reducescatter_blockiPiPKim_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL37nvshmemx_int_prod_reducescatter_blockiPiPKim_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(int_prod_reducescatter_block, int32, CPointer(int32), CPointer(int32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL37nvshmemx_int_prod_reducescatter_blockiPiPKim_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL37nvshmemx_int_prod_reducescatter_blockiPiPKim_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int32)), CPointer(CPointer(int32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL37nvshmemx_int_prod_reducescatter_blockiPiPKim_nbst(shim_stream, shim_obj)


def long_prod_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_long_prod_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_long_prod_reducescatter_blockiPlPKlm_nbst(int &retval , int* team, long ** dest, long ** source, unsigned long* nreduce) {
        retval = nvshmemx_long_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_long_prod_reducescatter_blockiPlPKlm_nbst = declare_device(
        '_ZL38nvshmemx_long_prod_reducescatter_blockiPlPKlm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_long_prod_reducescatter_blockiPlPKlm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_long_prod_reducescatter_blockiPlPKlm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(long_prod_reducescatter_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_long_prod_reducescatter_blockiPlPKlm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_long_prod_reducescatter_blockiPlPKlm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_long_prod_reducescatter_blockiPlPKlm_nbst(shim_stream, shim_obj)


def longlong_prod_reducescatter_block():
    pass
    

def _lower__ZL42nvshmemx_longlong_prod_reducescatter_blockiPxPKxm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL42nvshmemx_longlong_prod_reducescatter_blockiPxPKxm_nbst(int &retval , int* team, long long ** dest, long long ** source, unsigned long* nreduce) {
        retval = nvshmemx_longlong_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL42nvshmemx_longlong_prod_reducescatter_blockiPxPKxm_nbst = declare_device(
        '_ZL42nvshmemx_longlong_prod_reducescatter_blockiPxPKxm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)
        )
    )
    

    def _ZL42nvshmemx_longlong_prod_reducescatter_blockiPxPKxm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL42nvshmemx_longlong_prod_reducescatter_blockiPxPKxm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(longlong_prod_reducescatter_block, int32, CPointer(int64), CPointer(int64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL42nvshmemx_longlong_prod_reducescatter_blockiPxPKxm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL42nvshmemx_longlong_prod_reducescatter_blockiPxPKxm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(int64)), CPointer(CPointer(int64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL42nvshmemx_longlong_prod_reducescatter_blockiPxPKxm_nbst(shim_stream, shim_obj)


def bfloat16_prod_reducescatter_block():
    pass
    

def _lower__ZL42nvshmemx_bfloat16_prod_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL42nvshmemx_bfloat16_prod_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst(int &retval , int* team, __nv_bfloat16 ** dest, __nv_bfloat16 ** source, unsigned long* nreduce) {
        retval = nvshmemx_bfloat16_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL42nvshmemx_bfloat16_prod_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst = declare_device(
        '_ZL42nvshmemx_bfloat16_prod_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)
        )
    )
    

    def _ZL42nvshmemx_bfloat16_prod_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL42nvshmemx_bfloat16_prod_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(bfloat16_prod_reducescatter_block, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL42nvshmemx_bfloat16_prod_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL42nvshmemx_bfloat16_prod_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(bfloat16)), CPointer(CPointer(bfloat16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL42nvshmemx_bfloat16_prod_reducescatter_blockiP13__nv_bfloat16PKS_m_nbst(shim_stream, shim_obj)


def half_prod_reducescatter_block():
    pass
    

def _lower__ZL38nvshmemx_half_prod_reducescatter_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL38nvshmemx_half_prod_reducescatter_blockiP6__halfPKS_m_nbst(int &retval , int* team, __half ** dest, __half ** source, unsigned long* nreduce) {
        retval = nvshmemx_half_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL38nvshmemx_half_prod_reducescatter_blockiP6__halfPKS_m_nbst = declare_device(
        '_ZL38nvshmemx_half_prod_reducescatter_blockiP6__halfPKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)
        )
    )
    

    def _ZL38nvshmemx_half_prod_reducescatter_blockiP6__halfPKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL38nvshmemx_half_prod_reducescatter_blockiP6__halfPKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(half_prod_reducescatter_block, int32, CPointer(float16), CPointer(float16), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL38nvshmemx_half_prod_reducescatter_blockiP6__halfPKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL38nvshmemx_half_prod_reducescatter_blockiP6__halfPKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float16)), CPointer(CPointer(float16)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL38nvshmemx_half_prod_reducescatter_blockiP6__halfPKS_m_nbst(shim_stream, shim_obj)


def float_prod_reducescatter_block():
    pass
    

def _lower__ZL39nvshmemx_float_prod_reducescatter_blockiPfPKfm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL39nvshmemx_float_prod_reducescatter_blockiPfPKfm_nbst(int &retval , int* team, float ** dest, float ** source, unsigned long* nreduce) {
        retval = nvshmemx_float_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL39nvshmemx_float_prod_reducescatter_blockiPfPKfm_nbst = declare_device(
        '_ZL39nvshmemx_float_prod_reducescatter_blockiPfPKfm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)
        )
    )
    

    def _ZL39nvshmemx_float_prod_reducescatter_blockiPfPKfm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL39nvshmemx_float_prod_reducescatter_blockiPfPKfm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(float_prod_reducescatter_block, int32, CPointer(float32), CPointer(float32), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL39nvshmemx_float_prod_reducescatter_blockiPfPKfm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL39nvshmemx_float_prod_reducescatter_blockiPfPKfm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float32)), CPointer(CPointer(float32)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL39nvshmemx_float_prod_reducescatter_blockiPfPKfm_nbst(shim_stream, shim_obj)


def double_prod_reducescatter_block():
    pass
    

def _lower__ZL40nvshmemx_double_prod_reducescatter_blockiPdPKdm_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL40nvshmemx_double_prod_reducescatter_blockiPdPKdm_nbst(int &retval , int* team, double ** dest, double ** source, unsigned long* nreduce) {
        retval = nvshmemx_double_prod_reducescatter_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL40nvshmemx_double_prod_reducescatter_blockiPdPKdm_nbst = declare_device(
        '_ZL40nvshmemx_double_prod_reducescatter_blockiPdPKdm_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)
        )
    )
    

    def _ZL40nvshmemx_double_prod_reducescatter_blockiPdPKdm_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL40nvshmemx_double_prod_reducescatter_blockiPdPKdm_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double_prod_reducescatter_block, int32, CPointer(float64), CPointer(float64), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL40nvshmemx_double_prod_reducescatter_blockiPdPKdm_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL40nvshmemx_double_prod_reducescatter_blockiPdPKdm_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64)), CPointer(CPointer(float64)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL40nvshmemx_double_prod_reducescatter_blockiPdPKdm_nbst(shim_stream, shim_obj)


def double2_maxloc_reduce_block():
    pass
    

def _lower__ZL36nvshmemx_double2_maxloc_reduce_blockiP7double2PKS_m_nbst(shim_stream, shim_obj):


    shim_raw_str = """
    extern "C" __device__ int
    _ZL36nvshmemx_double2_maxloc_reduce_blockiP7double2PKS_m_nbst(int &retval , int* team, double2 ** dest, double2 ** source, unsigned long* nreduce) {
        retval = nvshmemx_double2_maxloc_reduce_block(*team, *dest, *source, *nreduce);
        return 0;
    }
        """


    _ZL36nvshmemx_double2_maxloc_reduce_blockiP7double2PKS_m_nbst = declare_device(
        '_ZL36nvshmemx_double2_maxloc_reduce_blockiP7double2PKS_m_nbst',
        int32(
            CPointer(int32), CPointer(CPointer(float64x2)), CPointer(CPointer(float64x2)), CPointer(uint64)
        )
    )
    

    def _ZL36nvshmemx_double2_maxloc_reduce_blockiP7double2PKS_m_nbst_caller(arg_0, arg_1, arg_2, arg_3):
        return _ZL36nvshmemx_double2_maxloc_reduce_blockiP7double2PKS_m_nbst(arg_0, arg_1, arg_2, arg_3)
    

    @lower(double2_maxloc_reduce_block, int32, CPointer(float64x2), CPointer(float64x2), uint64)
    def impl(context, builder, sig, args):
        context.active_code_library.add_linking_file(shim_obj)
        shim_stream.write_with_key("_ZL36nvshmemx_double2_maxloc_reduce_blockiP7double2PKS_m_nbst", shim_raw_str)
        ptrs = [builder.alloca(context.get_value_type(arg)) for arg in sig.args]
        for ptr, ty, arg in zip(ptrs, sig.args, args):
            builder.store(arg, ptr, align=getattr(ty, "alignof_", None))

        return context.compile_internal(
            builder,
            _ZL36nvshmemx_double2_maxloc_reduce_blockiP7double2PKS_m_nbst_caller,
            signature(int32, CPointer(int32), CPointer(CPointer(float64x2)), CPointer(CPointer(float64x2)), CPointer(uint64)),
            ptrs,
        )



_lower__ZL36nvshmemx_double2_maxloc_reduce_blockiP7double2PKS_m_nbst(shim_stream, shim_obj)


@register
class _typing_team_my_pe(ConcreteTemplate):
    key = globals()["team_my_pe"]
    cases = [signature(int32, int32)]

register_global(team_my_pe, types.Function(_typing_team_my_pe))


@register
class _typing_team_n_pes(ConcreteTemplate):
    key = globals()["team_n_pes"]
    cases = [signature(int32, int32)]

register_global(team_n_pes, types.Function(_typing_team_n_pes))


@register
class _typing_team_translate_pe(ConcreteTemplate):
    key = globals()["team_translate_pe"]
    cases = [signature(int32, int32, int32, int32)]

register_global(team_translate_pe, types.Function(_typing_team_translate_pe))


@register
class _typing_my_pe(ConcreteTemplate):
    key = globals()["my_pe"]
    cases = [signature(int32, )]

register_global(my_pe, types.Function(_typing_my_pe))


@register
class _typing_n_pes(ConcreteTemplate):
    key = globals()["n_pes"]
    cases = [signature(int32, )]

register_global(n_pes, types.Function(_typing_n_pes))


@register
class _typing_info_get_name(ConcreteTemplate):
    key = globals()["info_get_name"]
    cases = [signature(void, CPointer(int8))]

register_global(info_get_name, types.Function(_typing_info_get_name))


@register
class _typing_info_get_version(ConcreteTemplate):
    key = globals()["info_get_version"]
    cases = [signature(void, CPointer(int32), CPointer(int32))]

register_global(info_get_version, types.Function(_typing_info_get_version))


@register
class _typing_bfloat16_p(ConcreteTemplate):
    key = globals()["bfloat16_p"]
    cases = [signature(void, CPointer(bfloat16), bfloat16, int32)]

register_global(bfloat16_p, types.Function(_typing_bfloat16_p))


@register
class _typing_half_p(ConcreteTemplate):
    key = globals()["half_p"]
    cases = [signature(void, CPointer(float16), float16, int32)]

register_global(half_p, types.Function(_typing_half_p))


@register
class _typing_float_p(ConcreteTemplate):
    key = globals()["float_p"]
    cases = [signature(void, CPointer(float32), float32, int32)]

register_global(float_p, types.Function(_typing_float_p))


@register
class _typing_double_p(ConcreteTemplate):
    key = globals()["double_p"]
    cases = [signature(void, CPointer(float64), float64, int32)]

register_global(double_p, types.Function(_typing_double_p))


@register
class _typing_char_p(ConcreteTemplate):
    key = globals()["char_p"]
    cases = [signature(void, CPointer(int8), int8, int32)]

register_global(char_p, types.Function(_typing_char_p))


@register
class _typing_short_p(ConcreteTemplate):
    key = globals()["short_p"]
    cases = [signature(void, CPointer(int16), int16, int32)]

register_global(short_p, types.Function(_typing_short_p))


@register
class _typing_schar_p(ConcreteTemplate):
    key = globals()["schar_p"]
    cases = [signature(void, CPointer(int8), int8, int32)]

register_global(schar_p, types.Function(_typing_schar_p))


@register
class _typing_int_p(ConcreteTemplate):
    key = globals()["int_p"]
    cases = [signature(void, CPointer(int32), int32, int32)]

register_global(int_p, types.Function(_typing_int_p))


@register
class _typing_long_p(ConcreteTemplate):
    key = globals()["long_p"]
    cases = [signature(void, CPointer(int64), int64, int32)]

register_global(long_p, types.Function(_typing_long_p))


@register
class _typing_longlong_p(ConcreteTemplate):
    key = globals()["longlong_p"]
    cases = [signature(void, CPointer(int64), int64, int32)]

register_global(longlong_p, types.Function(_typing_longlong_p))


@register
class _typing_uchar_p(ConcreteTemplate):
    key = globals()["uchar_p"]
    cases = [signature(void, CPointer(uint8), uint8, int32)]

register_global(uchar_p, types.Function(_typing_uchar_p))


@register
class _typing_ushort_p(ConcreteTemplate):
    key = globals()["ushort_p"]
    cases = [signature(void, CPointer(uint16), uint16, int32)]

register_global(ushort_p, types.Function(_typing_ushort_p))


@register
class _typing_uint_p(ConcreteTemplate):
    key = globals()["uint_p"]
    cases = [signature(void, CPointer(uint32), uint32, int32)]

register_global(uint_p, types.Function(_typing_uint_p))


@register
class _typing_ulong_p(ConcreteTemplate):
    key = globals()["ulong_p"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(ulong_p, types.Function(_typing_ulong_p))


@register
class _typing_ulonglong_p(ConcreteTemplate):
    key = globals()["ulonglong_p"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(ulonglong_p, types.Function(_typing_ulonglong_p))


@register
class _typing_int8_p(ConcreteTemplate):
    key = globals()["int8_p"]
    cases = [signature(void, CPointer(int8), int8, int32)]

register_global(int8_p, types.Function(_typing_int8_p))


@register
class _typing_int16_p(ConcreteTemplate):
    key = globals()["int16_p"]
    cases = [signature(void, CPointer(int16), int16, int32)]

register_global(int16_p, types.Function(_typing_int16_p))


@register
class _typing_int32_p(ConcreteTemplate):
    key = globals()["int32_p"]
    cases = [signature(void, CPointer(int32), int32, int32)]

register_global(int32_p, types.Function(_typing_int32_p))


@register
class _typing_int64_p(ConcreteTemplate):
    key = globals()["int64_p"]
    cases = [signature(void, CPointer(int64), int64, int32)]

register_global(int64_p, types.Function(_typing_int64_p))


@register
class _typing_uint8_p(ConcreteTemplate):
    key = globals()["uint8_p"]
    cases = [signature(void, CPointer(uint8), uint8, int32)]

register_global(uint8_p, types.Function(_typing_uint8_p))


@register
class _typing_uint16_p(ConcreteTemplate):
    key = globals()["uint16_p"]
    cases = [signature(void, CPointer(uint16), uint16, int32)]

register_global(uint16_p, types.Function(_typing_uint16_p))


@register
class _typing_uint32_p(ConcreteTemplate):
    key = globals()["uint32_p"]
    cases = [signature(void, CPointer(uint32), uint32, int32)]

register_global(uint32_p, types.Function(_typing_uint32_p))


@register
class _typing_uint64_p(ConcreteTemplate):
    key = globals()["uint64_p"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(uint64_p, types.Function(_typing_uint64_p))


@register
class _typing_size_p(ConcreteTemplate):
    key = globals()["size_p"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(size_p, types.Function(_typing_size_p))


@register
class _typing_ptrdiff_p(ConcreteTemplate):
    key = globals()["ptrdiff_p"]
    cases = [signature(void, CPointer(int64), int64, int32)]

register_global(ptrdiff_p, types.Function(_typing_ptrdiff_p))


@register
class _typing_bfloat16_g(ConcreteTemplate):
    key = globals()["bfloat16_g"]
    cases = [signature(bfloat16, CPointer(bfloat16), int32)]

register_global(bfloat16_g, types.Function(_typing_bfloat16_g))


@register
class _typing_half_g(ConcreteTemplate):
    key = globals()["half_g"]
    cases = [signature(float16, CPointer(float16), int32)]

register_global(half_g, types.Function(_typing_half_g))


@register
class _typing_float_g(ConcreteTemplate):
    key = globals()["float_g"]
    cases = [signature(float32, CPointer(float32), int32)]

register_global(float_g, types.Function(_typing_float_g))


@register
class _typing_double_g(ConcreteTemplate):
    key = globals()["double_g"]
    cases = [signature(float64, CPointer(float64), int32)]

register_global(double_g, types.Function(_typing_double_g))


@register
class _typing_char_g(ConcreteTemplate):
    key = globals()["char_g"]
    cases = [signature(int8, CPointer(int8), int32)]

register_global(char_g, types.Function(_typing_char_g))


@register
class _typing_short_g(ConcreteTemplate):
    key = globals()["short_g"]
    cases = [signature(int16, CPointer(int16), int32)]

register_global(short_g, types.Function(_typing_short_g))


@register
class _typing_schar_g(ConcreteTemplate):
    key = globals()["schar_g"]
    cases = [signature(int8, CPointer(int8), int32)]

register_global(schar_g, types.Function(_typing_schar_g))


@register
class _typing_int_g(ConcreteTemplate):
    key = globals()["int_g"]
    cases = [signature(int32, CPointer(int32), int32)]

register_global(int_g, types.Function(_typing_int_g))


@register
class _typing_long_g(ConcreteTemplate):
    key = globals()["long_g"]
    cases = [signature(int64, CPointer(int64), int32)]

register_global(long_g, types.Function(_typing_long_g))


@register
class _typing_longlong_g(ConcreteTemplate):
    key = globals()["longlong_g"]
    cases = [signature(int64, CPointer(int64), int32)]

register_global(longlong_g, types.Function(_typing_longlong_g))


@register
class _typing_uchar_g(ConcreteTemplate):
    key = globals()["uchar_g"]
    cases = [signature(uint8, CPointer(uint8), int32)]

register_global(uchar_g, types.Function(_typing_uchar_g))


@register
class _typing_ushort_g(ConcreteTemplate):
    key = globals()["ushort_g"]
    cases = [signature(uint16, CPointer(uint16), int32)]

register_global(ushort_g, types.Function(_typing_ushort_g))


@register
class _typing_uint_g(ConcreteTemplate):
    key = globals()["uint_g"]
    cases = [signature(uint32, CPointer(uint32), int32)]

register_global(uint_g, types.Function(_typing_uint_g))


@register
class _typing_ulong_g(ConcreteTemplate):
    key = globals()["ulong_g"]
    cases = [signature(uint64, CPointer(uint64), int32)]

register_global(ulong_g, types.Function(_typing_ulong_g))


@register
class _typing_ulonglong_g(ConcreteTemplate):
    key = globals()["ulonglong_g"]
    cases = [signature(uint64, CPointer(uint64), int32)]

register_global(ulonglong_g, types.Function(_typing_ulonglong_g))


@register
class _typing_int8_g(ConcreteTemplate):
    key = globals()["int8_g"]
    cases = [signature(int8, CPointer(int8), int32)]

register_global(int8_g, types.Function(_typing_int8_g))


@register
class _typing_int16_g(ConcreteTemplate):
    key = globals()["int16_g"]
    cases = [signature(int16, CPointer(int16), int32)]

register_global(int16_g, types.Function(_typing_int16_g))


@register
class _typing_int32_g(ConcreteTemplate):
    key = globals()["int32_g"]
    cases = [signature(int32, CPointer(int32), int32)]

register_global(int32_g, types.Function(_typing_int32_g))


@register
class _typing_int64_g(ConcreteTemplate):
    key = globals()["int64_g"]
    cases = [signature(int64, CPointer(int64), int32)]

register_global(int64_g, types.Function(_typing_int64_g))


@register
class _typing_uint8_g(ConcreteTemplate):
    key = globals()["uint8_g"]
    cases = [signature(uint8, CPointer(uint8), int32)]

register_global(uint8_g, types.Function(_typing_uint8_g))


@register
class _typing_uint16_g(ConcreteTemplate):
    key = globals()["uint16_g"]
    cases = [signature(uint16, CPointer(uint16), int32)]

register_global(uint16_g, types.Function(_typing_uint16_g))


@register
class _typing_uint32_g(ConcreteTemplate):
    key = globals()["uint32_g"]
    cases = [signature(uint32, CPointer(uint32), int32)]

register_global(uint32_g, types.Function(_typing_uint32_g))


@register
class _typing_uint64_g(ConcreteTemplate):
    key = globals()["uint64_g"]
    cases = [signature(uint64, CPointer(uint64), int32)]

register_global(uint64_g, types.Function(_typing_uint64_g))


@register
class _typing_size_g(ConcreteTemplate):
    key = globals()["size_g"]
    cases = [signature(uint64, CPointer(uint64), int32)]

register_global(size_g, types.Function(_typing_size_g))


@register
class _typing_ptrdiff_g(ConcreteTemplate):
    key = globals()["ptrdiff_g"]
    cases = [signature(int64, CPointer(int64), int32)]

register_global(ptrdiff_g, types.Function(_typing_ptrdiff_g))


@register
class _typing_bfloat16_put(ConcreteTemplate):
    key = globals()["bfloat16_put"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)]

register_global(bfloat16_put, types.Function(_typing_bfloat16_put))


@register
class _typing_half_put(ConcreteTemplate):
    key = globals()["half_put"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32)]

register_global(half_put, types.Function(_typing_half_put))


@register
class _typing_float_put(ConcreteTemplate):
    key = globals()["float_put"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32)]

register_global(float_put, types.Function(_typing_float_put))


@register
class _typing_double_put(ConcreteTemplate):
    key = globals()["double_put"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32)]

register_global(double_put, types.Function(_typing_double_put))


@register
class _typing_char_put(ConcreteTemplate):
    key = globals()["char_put"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(char_put, types.Function(_typing_char_put))


@register
class _typing_short_put(ConcreteTemplate):
    key = globals()["short_put"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(short_put, types.Function(_typing_short_put))


@register
class _typing_schar_put(ConcreteTemplate):
    key = globals()["schar_put"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(schar_put, types.Function(_typing_schar_put))


@register
class _typing_int_put(ConcreteTemplate):
    key = globals()["int_put"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int_put, types.Function(_typing_int_put))


@register
class _typing_long_put(ConcreteTemplate):
    key = globals()["long_put"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(long_put, types.Function(_typing_long_put))


@register
class _typing_longlong_put(ConcreteTemplate):
    key = globals()["longlong_put"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(longlong_put, types.Function(_typing_longlong_put))


@register
class _typing_uchar_put(ConcreteTemplate):
    key = globals()["uchar_put"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uchar_put, types.Function(_typing_uchar_put))


@register
class _typing_ushort_put(ConcreteTemplate):
    key = globals()["ushort_put"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(ushort_put, types.Function(_typing_ushort_put))


@register
class _typing_uint_put(ConcreteTemplate):
    key = globals()["uint_put"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint_put, types.Function(_typing_uint_put))


@register
class _typing_ulong_put(ConcreteTemplate):
    key = globals()["ulong_put"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulong_put, types.Function(_typing_ulong_put))


@register
class _typing_ulonglong_put(ConcreteTemplate):
    key = globals()["ulonglong_put"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulonglong_put, types.Function(_typing_ulonglong_put))


@register
class _typing_int8_put(ConcreteTemplate):
    key = globals()["int8_put"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(int8_put, types.Function(_typing_int8_put))


@register
class _typing_int16_put(ConcreteTemplate):
    key = globals()["int16_put"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(int16_put, types.Function(_typing_int16_put))


@register
class _typing_int32_put(ConcreteTemplate):
    key = globals()["int32_put"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int32_put, types.Function(_typing_int32_put))


@register
class _typing_int64_put(ConcreteTemplate):
    key = globals()["int64_put"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(int64_put, types.Function(_typing_int64_put))


@register
class _typing_uint8_put(ConcreteTemplate):
    key = globals()["uint8_put"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uint8_put, types.Function(_typing_uint8_put))


@register
class _typing_uint16_put(ConcreteTemplate):
    key = globals()["uint16_put"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(uint16_put, types.Function(_typing_uint16_put))


@register
class _typing_uint32_put(ConcreteTemplate):
    key = globals()["uint32_put"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint32_put, types.Function(_typing_uint32_put))


@register
class _typing_uint64_put(ConcreteTemplate):
    key = globals()["uint64_put"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(uint64_put, types.Function(_typing_uint64_put))


@register
class _typing_size_put(ConcreteTemplate):
    key = globals()["size_put"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(size_put, types.Function(_typing_size_put))


@register
class _typing_ptrdiff_put(ConcreteTemplate):
    key = globals()["ptrdiff_put"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(ptrdiff_put, types.Function(_typing_ptrdiff_put))


@register
class _typing_bfloat16_put_signal(ConcreteTemplate):
    key = globals()["bfloat16_put_signal"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(bfloat16_put_signal, types.Function(_typing_bfloat16_put_signal))


@register
class _typing_half_put_signal(ConcreteTemplate):
    key = globals()["half_put_signal"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(half_put_signal, types.Function(_typing_half_put_signal))


@register
class _typing_float_put_signal(ConcreteTemplate):
    key = globals()["float_put_signal"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(float_put_signal, types.Function(_typing_float_put_signal))


@register
class _typing_double_put_signal(ConcreteTemplate):
    key = globals()["double_put_signal"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(double_put_signal, types.Function(_typing_double_put_signal))


@register
class _typing_char_put_signal(ConcreteTemplate):
    key = globals()["char_put_signal"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(char_put_signal, types.Function(_typing_char_put_signal))


@register
class _typing_short_put_signal(ConcreteTemplate):
    key = globals()["short_put_signal"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(short_put_signal, types.Function(_typing_short_put_signal))


@register
class _typing_schar_put_signal(ConcreteTemplate):
    key = globals()["schar_put_signal"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(schar_put_signal, types.Function(_typing_schar_put_signal))


@register
class _typing_int_put_signal(ConcreteTemplate):
    key = globals()["int_put_signal"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int_put_signal, types.Function(_typing_int_put_signal))


@register
class _typing_long_put_signal(ConcreteTemplate):
    key = globals()["long_put_signal"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(long_put_signal, types.Function(_typing_long_put_signal))


@register
class _typing_longlong_put_signal(ConcreteTemplate):
    key = globals()["longlong_put_signal"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(longlong_put_signal, types.Function(_typing_longlong_put_signal))


@register
class _typing_uchar_put_signal(ConcreteTemplate):
    key = globals()["uchar_put_signal"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uchar_put_signal, types.Function(_typing_uchar_put_signal))


@register
class _typing_ushort_put_signal(ConcreteTemplate):
    key = globals()["ushort_put_signal"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ushort_put_signal, types.Function(_typing_ushort_put_signal))


@register
class _typing_uint_put_signal(ConcreteTemplate):
    key = globals()["uint_put_signal"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint_put_signal, types.Function(_typing_uint_put_signal))


@register
class _typing_ulong_put_signal(ConcreteTemplate):
    key = globals()["ulong_put_signal"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ulong_put_signal, types.Function(_typing_ulong_put_signal))


@register
class _typing_ulonglong_put_signal(ConcreteTemplate):
    key = globals()["ulonglong_put_signal"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ulonglong_put_signal, types.Function(_typing_ulonglong_put_signal))


@register
class _typing_int8_put_signal(ConcreteTemplate):
    key = globals()["int8_put_signal"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int8_put_signal, types.Function(_typing_int8_put_signal))


@register
class _typing_int16_put_signal(ConcreteTemplate):
    key = globals()["int16_put_signal"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int16_put_signal, types.Function(_typing_int16_put_signal))


@register
class _typing_int32_put_signal(ConcreteTemplate):
    key = globals()["int32_put_signal"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int32_put_signal, types.Function(_typing_int32_put_signal))


@register
class _typing_int64_put_signal(ConcreteTemplate):
    key = globals()["int64_put_signal"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int64_put_signal, types.Function(_typing_int64_put_signal))


@register
class _typing_uint8_put_signal(ConcreteTemplate):
    key = globals()["uint8_put_signal"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint8_put_signal, types.Function(_typing_uint8_put_signal))


@register
class _typing_uint16_put_signal(ConcreteTemplate):
    key = globals()["uint16_put_signal"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint16_put_signal, types.Function(_typing_uint16_put_signal))


@register
class _typing_uint32_put_signal(ConcreteTemplate):
    key = globals()["uint32_put_signal"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint32_put_signal, types.Function(_typing_uint32_put_signal))


@register
class _typing_uint64_put_signal(ConcreteTemplate):
    key = globals()["uint64_put_signal"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint64_put_signal, types.Function(_typing_uint64_put_signal))


@register
class _typing_size_put_signal(ConcreteTemplate):
    key = globals()["size_put_signal"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(size_put_signal, types.Function(_typing_size_put_signal))


@register
class _typing_ptrdiff_put_signal(ConcreteTemplate):
    key = globals()["ptrdiff_put_signal"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ptrdiff_put_signal, types.Function(_typing_ptrdiff_put_signal))


@register
class _typing_bfloat16_get(ConcreteTemplate):
    key = globals()["bfloat16_get"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)]

register_global(bfloat16_get, types.Function(_typing_bfloat16_get))


@register
class _typing_half_get(ConcreteTemplate):
    key = globals()["half_get"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32)]

register_global(half_get, types.Function(_typing_half_get))


@register
class _typing_float_get(ConcreteTemplate):
    key = globals()["float_get"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32)]

register_global(float_get, types.Function(_typing_float_get))


@register
class _typing_double_get(ConcreteTemplate):
    key = globals()["double_get"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32)]

register_global(double_get, types.Function(_typing_double_get))


@register
class _typing_char_get(ConcreteTemplate):
    key = globals()["char_get"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(char_get, types.Function(_typing_char_get))


@register
class _typing_short_get(ConcreteTemplate):
    key = globals()["short_get"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(short_get, types.Function(_typing_short_get))


@register
class _typing_schar_get(ConcreteTemplate):
    key = globals()["schar_get"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(schar_get, types.Function(_typing_schar_get))


@register
class _typing_int_get(ConcreteTemplate):
    key = globals()["int_get"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int_get, types.Function(_typing_int_get))


@register
class _typing_long_get(ConcreteTemplate):
    key = globals()["long_get"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(long_get, types.Function(_typing_long_get))


@register
class _typing_longlong_get(ConcreteTemplate):
    key = globals()["longlong_get"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(longlong_get, types.Function(_typing_longlong_get))


@register
class _typing_uchar_get(ConcreteTemplate):
    key = globals()["uchar_get"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uchar_get, types.Function(_typing_uchar_get))


@register
class _typing_ushort_get(ConcreteTemplate):
    key = globals()["ushort_get"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(ushort_get, types.Function(_typing_ushort_get))


@register
class _typing_uint_get(ConcreteTemplate):
    key = globals()["uint_get"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint_get, types.Function(_typing_uint_get))


@register
class _typing_ulong_get(ConcreteTemplate):
    key = globals()["ulong_get"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulong_get, types.Function(_typing_ulong_get))


@register
class _typing_ulonglong_get(ConcreteTemplate):
    key = globals()["ulonglong_get"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulonglong_get, types.Function(_typing_ulonglong_get))


@register
class _typing_int8_get(ConcreteTemplate):
    key = globals()["int8_get"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(int8_get, types.Function(_typing_int8_get))


@register
class _typing_int16_get(ConcreteTemplate):
    key = globals()["int16_get"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(int16_get, types.Function(_typing_int16_get))


@register
class _typing_int32_get(ConcreteTemplate):
    key = globals()["int32_get"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int32_get, types.Function(_typing_int32_get))


@register
class _typing_int64_get(ConcreteTemplate):
    key = globals()["int64_get"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(int64_get, types.Function(_typing_int64_get))


@register
class _typing_uint8_get(ConcreteTemplate):
    key = globals()["uint8_get"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uint8_get, types.Function(_typing_uint8_get))


@register
class _typing_uint16_get(ConcreteTemplate):
    key = globals()["uint16_get"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(uint16_get, types.Function(_typing_uint16_get))


@register
class _typing_uint32_get(ConcreteTemplate):
    key = globals()["uint32_get"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint32_get, types.Function(_typing_uint32_get))


@register
class _typing_uint64_get(ConcreteTemplate):
    key = globals()["uint64_get"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(uint64_get, types.Function(_typing_uint64_get))


@register
class _typing_size_get(ConcreteTemplate):
    key = globals()["size_get"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(size_get, types.Function(_typing_size_get))


@register
class _typing_ptrdiff_get(ConcreteTemplate):
    key = globals()["ptrdiff_get"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(ptrdiff_get, types.Function(_typing_ptrdiff_get))


@register
class _typing_put8(ConcreteTemplate):
    key = globals()["put8"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put8, types.Function(_typing_put8))


@register
class _typing_put16(ConcreteTemplate):
    key = globals()["put16"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put16, types.Function(_typing_put16))


@register
class _typing_put32(ConcreteTemplate):
    key = globals()["put32"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put32, types.Function(_typing_put32))


@register
class _typing_put64(ConcreteTemplate):
    key = globals()["put64"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put64, types.Function(_typing_put64))


@register
class _typing_put128(ConcreteTemplate):
    key = globals()["put128"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put128, types.Function(_typing_put128))


@register
class _typing_putmem_signal(ConcreteTemplate):
    key = globals()["putmem_signal"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(putmem_signal, types.Function(_typing_putmem_signal))


@register
class _typing_put8_signal(ConcreteTemplate):
    key = globals()["put8_signal"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put8_signal, types.Function(_typing_put8_signal))


@register
class _typing_put16_signal(ConcreteTemplate):
    key = globals()["put16_signal"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put16_signal, types.Function(_typing_put16_signal))


@register
class _typing_put32_signal(ConcreteTemplate):
    key = globals()["put32_signal"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put32_signal, types.Function(_typing_put32_signal))


@register
class _typing_put64_signal(ConcreteTemplate):
    key = globals()["put64_signal"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put64_signal, types.Function(_typing_put64_signal))


@register
class _typing_put128_signal(ConcreteTemplate):
    key = globals()["put128_signal"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put128_signal, types.Function(_typing_put128_signal))


@register
class _typing_get8(ConcreteTemplate):
    key = globals()["get8"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get8, types.Function(_typing_get8))


@register
class _typing_get16(ConcreteTemplate):
    key = globals()["get16"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get16, types.Function(_typing_get16))


@register
class _typing_get32(ConcreteTemplate):
    key = globals()["get32"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get32, types.Function(_typing_get32))


@register
class _typing_get64(ConcreteTemplate):
    key = globals()["get64"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get64, types.Function(_typing_get64))


@register
class _typing_get128(ConcreteTemplate):
    key = globals()["get128"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get128, types.Function(_typing_get128))


@register
class _typing_putmem(ConcreteTemplate):
    key = globals()["putmem"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(putmem, types.Function(_typing_putmem))


@register
class _typing_getmem(ConcreteTemplate):
    key = globals()["getmem"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(getmem, types.Function(_typing_getmem))


@register
class _typing_bfloat16_put_nbi(ConcreteTemplate):
    key = globals()["bfloat16_put_nbi"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)]

register_global(bfloat16_put_nbi, types.Function(_typing_bfloat16_put_nbi))


@register
class _typing_half_put_nbi(ConcreteTemplate):
    key = globals()["half_put_nbi"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32)]

register_global(half_put_nbi, types.Function(_typing_half_put_nbi))


@register
class _typing_float_put_nbi(ConcreteTemplate):
    key = globals()["float_put_nbi"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32)]

register_global(float_put_nbi, types.Function(_typing_float_put_nbi))


@register
class _typing_double_put_nbi(ConcreteTemplate):
    key = globals()["double_put_nbi"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32)]

register_global(double_put_nbi, types.Function(_typing_double_put_nbi))


@register
class _typing_char_put_nbi(ConcreteTemplate):
    key = globals()["char_put_nbi"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(char_put_nbi, types.Function(_typing_char_put_nbi))


@register
class _typing_short_put_nbi(ConcreteTemplate):
    key = globals()["short_put_nbi"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(short_put_nbi, types.Function(_typing_short_put_nbi))


@register
class _typing_schar_put_nbi(ConcreteTemplate):
    key = globals()["schar_put_nbi"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(schar_put_nbi, types.Function(_typing_schar_put_nbi))


@register
class _typing_int_put_nbi(ConcreteTemplate):
    key = globals()["int_put_nbi"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int_put_nbi, types.Function(_typing_int_put_nbi))


@register
class _typing_long_put_nbi(ConcreteTemplate):
    key = globals()["long_put_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(long_put_nbi, types.Function(_typing_long_put_nbi))


@register
class _typing_longlong_put_nbi(ConcreteTemplate):
    key = globals()["longlong_put_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(longlong_put_nbi, types.Function(_typing_longlong_put_nbi))


@register
class _typing_uchar_put_nbi(ConcreteTemplate):
    key = globals()["uchar_put_nbi"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uchar_put_nbi, types.Function(_typing_uchar_put_nbi))


@register
class _typing_ushort_put_nbi(ConcreteTemplate):
    key = globals()["ushort_put_nbi"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(ushort_put_nbi, types.Function(_typing_ushort_put_nbi))


@register
class _typing_uint_put_nbi(ConcreteTemplate):
    key = globals()["uint_put_nbi"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint_put_nbi, types.Function(_typing_uint_put_nbi))


@register
class _typing_ulong_put_nbi(ConcreteTemplate):
    key = globals()["ulong_put_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulong_put_nbi, types.Function(_typing_ulong_put_nbi))


@register
class _typing_ulonglong_put_nbi(ConcreteTemplate):
    key = globals()["ulonglong_put_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulonglong_put_nbi, types.Function(_typing_ulonglong_put_nbi))


@register
class _typing_int8_put_nbi(ConcreteTemplate):
    key = globals()["int8_put_nbi"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(int8_put_nbi, types.Function(_typing_int8_put_nbi))


@register
class _typing_int16_put_nbi(ConcreteTemplate):
    key = globals()["int16_put_nbi"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(int16_put_nbi, types.Function(_typing_int16_put_nbi))


@register
class _typing_int32_put_nbi(ConcreteTemplate):
    key = globals()["int32_put_nbi"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int32_put_nbi, types.Function(_typing_int32_put_nbi))


@register
class _typing_int64_put_nbi(ConcreteTemplate):
    key = globals()["int64_put_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(int64_put_nbi, types.Function(_typing_int64_put_nbi))


@register
class _typing_uint8_put_nbi(ConcreteTemplate):
    key = globals()["uint8_put_nbi"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uint8_put_nbi, types.Function(_typing_uint8_put_nbi))


@register
class _typing_uint16_put_nbi(ConcreteTemplate):
    key = globals()["uint16_put_nbi"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(uint16_put_nbi, types.Function(_typing_uint16_put_nbi))


@register
class _typing_uint32_put_nbi(ConcreteTemplate):
    key = globals()["uint32_put_nbi"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint32_put_nbi, types.Function(_typing_uint32_put_nbi))


@register
class _typing_uint64_put_nbi(ConcreteTemplate):
    key = globals()["uint64_put_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(uint64_put_nbi, types.Function(_typing_uint64_put_nbi))


@register
class _typing_size_put_nbi(ConcreteTemplate):
    key = globals()["size_put_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(size_put_nbi, types.Function(_typing_size_put_nbi))


@register
class _typing_ptrdiff_put_nbi(ConcreteTemplate):
    key = globals()["ptrdiff_put_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(ptrdiff_put_nbi, types.Function(_typing_ptrdiff_put_nbi))


@register
class _typing_bfloat16_put_signal_nbi(ConcreteTemplate):
    key = globals()["bfloat16_put_signal_nbi"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(bfloat16_put_signal_nbi, types.Function(_typing_bfloat16_put_signal_nbi))


@register
class _typing_half_put_signal_nbi(ConcreteTemplate):
    key = globals()["half_put_signal_nbi"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(half_put_signal_nbi, types.Function(_typing_half_put_signal_nbi))


@register
class _typing_float_put_signal_nbi(ConcreteTemplate):
    key = globals()["float_put_signal_nbi"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(float_put_signal_nbi, types.Function(_typing_float_put_signal_nbi))


@register
class _typing_double_put_signal_nbi(ConcreteTemplate):
    key = globals()["double_put_signal_nbi"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(double_put_signal_nbi, types.Function(_typing_double_put_signal_nbi))


@register
class _typing_char_put_signal_nbi(ConcreteTemplate):
    key = globals()["char_put_signal_nbi"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(char_put_signal_nbi, types.Function(_typing_char_put_signal_nbi))


@register
class _typing_short_put_signal_nbi(ConcreteTemplate):
    key = globals()["short_put_signal_nbi"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(short_put_signal_nbi, types.Function(_typing_short_put_signal_nbi))


@register
class _typing_schar_put_signal_nbi(ConcreteTemplate):
    key = globals()["schar_put_signal_nbi"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(schar_put_signal_nbi, types.Function(_typing_schar_put_signal_nbi))


@register
class _typing_int_put_signal_nbi(ConcreteTemplate):
    key = globals()["int_put_signal_nbi"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int_put_signal_nbi, types.Function(_typing_int_put_signal_nbi))


@register
class _typing_long_put_signal_nbi(ConcreteTemplate):
    key = globals()["long_put_signal_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(long_put_signal_nbi, types.Function(_typing_long_put_signal_nbi))


@register
class _typing_longlong_put_signal_nbi(ConcreteTemplate):
    key = globals()["longlong_put_signal_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(longlong_put_signal_nbi, types.Function(_typing_longlong_put_signal_nbi))


@register
class _typing_uchar_put_signal_nbi(ConcreteTemplate):
    key = globals()["uchar_put_signal_nbi"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uchar_put_signal_nbi, types.Function(_typing_uchar_put_signal_nbi))


@register
class _typing_ushort_put_signal_nbi(ConcreteTemplate):
    key = globals()["ushort_put_signal_nbi"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ushort_put_signal_nbi, types.Function(_typing_ushort_put_signal_nbi))


@register
class _typing_uint_put_signal_nbi(ConcreteTemplate):
    key = globals()["uint_put_signal_nbi"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint_put_signal_nbi, types.Function(_typing_uint_put_signal_nbi))


@register
class _typing_ulong_put_signal_nbi(ConcreteTemplate):
    key = globals()["ulong_put_signal_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ulong_put_signal_nbi, types.Function(_typing_ulong_put_signal_nbi))


@register
class _typing_ulonglong_put_signal_nbi(ConcreteTemplate):
    key = globals()["ulonglong_put_signal_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ulonglong_put_signal_nbi, types.Function(_typing_ulonglong_put_signal_nbi))


@register
class _typing_int8_put_signal_nbi(ConcreteTemplate):
    key = globals()["int8_put_signal_nbi"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int8_put_signal_nbi, types.Function(_typing_int8_put_signal_nbi))


@register
class _typing_int16_put_signal_nbi(ConcreteTemplate):
    key = globals()["int16_put_signal_nbi"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int16_put_signal_nbi, types.Function(_typing_int16_put_signal_nbi))


@register
class _typing_int32_put_signal_nbi(ConcreteTemplate):
    key = globals()["int32_put_signal_nbi"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int32_put_signal_nbi, types.Function(_typing_int32_put_signal_nbi))


@register
class _typing_int64_put_signal_nbi(ConcreteTemplate):
    key = globals()["int64_put_signal_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int64_put_signal_nbi, types.Function(_typing_int64_put_signal_nbi))


@register
class _typing_uint8_put_signal_nbi(ConcreteTemplate):
    key = globals()["uint8_put_signal_nbi"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint8_put_signal_nbi, types.Function(_typing_uint8_put_signal_nbi))


@register
class _typing_uint16_put_signal_nbi(ConcreteTemplate):
    key = globals()["uint16_put_signal_nbi"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint16_put_signal_nbi, types.Function(_typing_uint16_put_signal_nbi))


@register
class _typing_uint32_put_signal_nbi(ConcreteTemplate):
    key = globals()["uint32_put_signal_nbi"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint32_put_signal_nbi, types.Function(_typing_uint32_put_signal_nbi))


@register
class _typing_uint64_put_signal_nbi(ConcreteTemplate):
    key = globals()["uint64_put_signal_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint64_put_signal_nbi, types.Function(_typing_uint64_put_signal_nbi))


@register
class _typing_size_put_signal_nbi(ConcreteTemplate):
    key = globals()["size_put_signal_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(size_put_signal_nbi, types.Function(_typing_size_put_signal_nbi))


@register
class _typing_ptrdiff_put_signal_nbi(ConcreteTemplate):
    key = globals()["ptrdiff_put_signal_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ptrdiff_put_signal_nbi, types.Function(_typing_ptrdiff_put_signal_nbi))


@register
class _typing_bfloat16_get_nbi(ConcreteTemplate):
    key = globals()["bfloat16_get_nbi"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)]

register_global(bfloat16_get_nbi, types.Function(_typing_bfloat16_get_nbi))


@register
class _typing_half_get_nbi(ConcreteTemplate):
    key = globals()["half_get_nbi"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32)]

register_global(half_get_nbi, types.Function(_typing_half_get_nbi))


@register
class _typing_float_get_nbi(ConcreteTemplate):
    key = globals()["float_get_nbi"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32)]

register_global(float_get_nbi, types.Function(_typing_float_get_nbi))


@register
class _typing_double_get_nbi(ConcreteTemplate):
    key = globals()["double_get_nbi"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32)]

register_global(double_get_nbi, types.Function(_typing_double_get_nbi))


@register
class _typing_char_get_nbi(ConcreteTemplate):
    key = globals()["char_get_nbi"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(char_get_nbi, types.Function(_typing_char_get_nbi))


@register
class _typing_short_get_nbi(ConcreteTemplate):
    key = globals()["short_get_nbi"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(short_get_nbi, types.Function(_typing_short_get_nbi))


@register
class _typing_schar_get_nbi(ConcreteTemplate):
    key = globals()["schar_get_nbi"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(schar_get_nbi, types.Function(_typing_schar_get_nbi))


@register
class _typing_int_get_nbi(ConcreteTemplate):
    key = globals()["int_get_nbi"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int_get_nbi, types.Function(_typing_int_get_nbi))


@register
class _typing_long_get_nbi(ConcreteTemplate):
    key = globals()["long_get_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(long_get_nbi, types.Function(_typing_long_get_nbi))


@register
class _typing_longlong_get_nbi(ConcreteTemplate):
    key = globals()["longlong_get_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(longlong_get_nbi, types.Function(_typing_longlong_get_nbi))


@register
class _typing_uchar_get_nbi(ConcreteTemplate):
    key = globals()["uchar_get_nbi"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uchar_get_nbi, types.Function(_typing_uchar_get_nbi))


@register
class _typing_ushort_get_nbi(ConcreteTemplate):
    key = globals()["ushort_get_nbi"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(ushort_get_nbi, types.Function(_typing_ushort_get_nbi))


@register
class _typing_uint_get_nbi(ConcreteTemplate):
    key = globals()["uint_get_nbi"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint_get_nbi, types.Function(_typing_uint_get_nbi))


@register
class _typing_ulong_get_nbi(ConcreteTemplate):
    key = globals()["ulong_get_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulong_get_nbi, types.Function(_typing_ulong_get_nbi))


@register
class _typing_ulonglong_get_nbi(ConcreteTemplate):
    key = globals()["ulonglong_get_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulonglong_get_nbi, types.Function(_typing_ulonglong_get_nbi))


@register
class _typing_int8_get_nbi(ConcreteTemplate):
    key = globals()["int8_get_nbi"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(int8_get_nbi, types.Function(_typing_int8_get_nbi))


@register
class _typing_int16_get_nbi(ConcreteTemplate):
    key = globals()["int16_get_nbi"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(int16_get_nbi, types.Function(_typing_int16_get_nbi))


@register
class _typing_int32_get_nbi(ConcreteTemplate):
    key = globals()["int32_get_nbi"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int32_get_nbi, types.Function(_typing_int32_get_nbi))


@register
class _typing_int64_get_nbi(ConcreteTemplate):
    key = globals()["int64_get_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(int64_get_nbi, types.Function(_typing_int64_get_nbi))


@register
class _typing_uint8_get_nbi(ConcreteTemplate):
    key = globals()["uint8_get_nbi"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uint8_get_nbi, types.Function(_typing_uint8_get_nbi))


@register
class _typing_uint16_get_nbi(ConcreteTemplate):
    key = globals()["uint16_get_nbi"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(uint16_get_nbi, types.Function(_typing_uint16_get_nbi))


@register
class _typing_uint32_get_nbi(ConcreteTemplate):
    key = globals()["uint32_get_nbi"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint32_get_nbi, types.Function(_typing_uint32_get_nbi))


@register
class _typing_uint64_get_nbi(ConcreteTemplate):
    key = globals()["uint64_get_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(uint64_get_nbi, types.Function(_typing_uint64_get_nbi))


@register
class _typing_size_get_nbi(ConcreteTemplate):
    key = globals()["size_get_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(size_get_nbi, types.Function(_typing_size_get_nbi))


@register
class _typing_ptrdiff_get_nbi(ConcreteTemplate):
    key = globals()["ptrdiff_get_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(ptrdiff_get_nbi, types.Function(_typing_ptrdiff_get_nbi))


@register
class _typing_put8_nbi(ConcreteTemplate):
    key = globals()["put8_nbi"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put8_nbi, types.Function(_typing_put8_nbi))


@register
class _typing_put16_nbi(ConcreteTemplate):
    key = globals()["put16_nbi"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put16_nbi, types.Function(_typing_put16_nbi))


@register
class _typing_put32_nbi(ConcreteTemplate):
    key = globals()["put32_nbi"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put32_nbi, types.Function(_typing_put32_nbi))


@register
class _typing_put64_nbi(ConcreteTemplate):
    key = globals()["put64_nbi"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put64_nbi, types.Function(_typing_put64_nbi))


@register
class _typing_put128_nbi(ConcreteTemplate):
    key = globals()["put128_nbi"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put128_nbi, types.Function(_typing_put128_nbi))


@register
class _typing_get8_nbi(ConcreteTemplate):
    key = globals()["get8_nbi"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get8_nbi, types.Function(_typing_get8_nbi))


@register
class _typing_get16_nbi(ConcreteTemplate):
    key = globals()["get16_nbi"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get16_nbi, types.Function(_typing_get16_nbi))


@register
class _typing_get32_nbi(ConcreteTemplate):
    key = globals()["get32_nbi"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get32_nbi, types.Function(_typing_get32_nbi))


@register
class _typing_get64_nbi(ConcreteTemplate):
    key = globals()["get64_nbi"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get64_nbi, types.Function(_typing_get64_nbi))


@register
class _typing_get128_nbi(ConcreteTemplate):
    key = globals()["get128_nbi"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get128_nbi, types.Function(_typing_get128_nbi))


@register
class _typing_putmem_nbi(ConcreteTemplate):
    key = globals()["putmem_nbi"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(putmem_nbi, types.Function(_typing_putmem_nbi))


@register
class _typing_putmem_signal_nbi(ConcreteTemplate):
    key = globals()["putmem_signal_nbi"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(putmem_signal_nbi, types.Function(_typing_putmem_signal_nbi))


@register
class _typing_put8_signal_nbi(ConcreteTemplate):
    key = globals()["put8_signal_nbi"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put8_signal_nbi, types.Function(_typing_put8_signal_nbi))


@register
class _typing_put16_signal_nbi(ConcreteTemplate):
    key = globals()["put16_signal_nbi"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put16_signal_nbi, types.Function(_typing_put16_signal_nbi))


@register
class _typing_put32_signal_nbi(ConcreteTemplate):
    key = globals()["put32_signal_nbi"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put32_signal_nbi, types.Function(_typing_put32_signal_nbi))


@register
class _typing_put64_signal_nbi(ConcreteTemplate):
    key = globals()["put64_signal_nbi"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put64_signal_nbi, types.Function(_typing_put64_signal_nbi))


@register
class _typing_put128_signal_nbi(ConcreteTemplate):
    key = globals()["put128_signal_nbi"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put128_signal_nbi, types.Function(_typing_put128_signal_nbi))


@register
class _typing_getmem_nbi(ConcreteTemplate):
    key = globals()["getmem_nbi"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(getmem_nbi, types.Function(_typing_getmem_nbi))


@register
class _typing_bfloat16_iput(ConcreteTemplate):
    key = globals()["bfloat16_iput"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), int64, int64, uint64, int32)]

register_global(bfloat16_iput, types.Function(_typing_bfloat16_iput))


@register
class _typing_half_iput(ConcreteTemplate):
    key = globals()["half_iput"]
    cases = [signature(void, CPointer(float16), CPointer(float16), int64, int64, uint64, int32)]

register_global(half_iput, types.Function(_typing_half_iput))


@register
class _typing_float_iput(ConcreteTemplate):
    key = globals()["float_iput"]
    cases = [signature(void, CPointer(float32), CPointer(float32), int64, int64, uint64, int32)]

register_global(float_iput, types.Function(_typing_float_iput))


@register
class _typing_double_iput(ConcreteTemplate):
    key = globals()["double_iput"]
    cases = [signature(void, CPointer(float64), CPointer(float64), int64, int64, uint64, int32)]

register_global(double_iput, types.Function(_typing_double_iput))


@register
class _typing_char_iput(ConcreteTemplate):
    key = globals()["char_iput"]
    cases = [signature(void, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)]

register_global(char_iput, types.Function(_typing_char_iput))


@register
class _typing_short_iput(ConcreteTemplate):
    key = globals()["short_iput"]
    cases = [signature(void, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)]

register_global(short_iput, types.Function(_typing_short_iput))


@register
class _typing_schar_iput(ConcreteTemplate):
    key = globals()["schar_iput"]
    cases = [signature(void, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)]

register_global(schar_iput, types.Function(_typing_schar_iput))


@register
class _typing_int_iput(ConcreteTemplate):
    key = globals()["int_iput"]
    cases = [signature(void, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)]

register_global(int_iput, types.Function(_typing_int_iput))


@register
class _typing_long_iput(ConcreteTemplate):
    key = globals()["long_iput"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(long_iput, types.Function(_typing_long_iput))


@register
class _typing_longlong_iput(ConcreteTemplate):
    key = globals()["longlong_iput"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(longlong_iput, types.Function(_typing_longlong_iput))


@register
class _typing_uchar_iput(ConcreteTemplate):
    key = globals()["uchar_iput"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)]

register_global(uchar_iput, types.Function(_typing_uchar_iput))


@register
class _typing_ushort_iput(ConcreteTemplate):
    key = globals()["ushort_iput"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)]

register_global(ushort_iput, types.Function(_typing_ushort_iput))


@register
class _typing_uint_iput(ConcreteTemplate):
    key = globals()["uint_iput"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)]

register_global(uint_iput, types.Function(_typing_uint_iput))


@register
class _typing_ulong_iput(ConcreteTemplate):
    key = globals()["ulong_iput"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(ulong_iput, types.Function(_typing_ulong_iput))


@register
class _typing_ulonglong_iput(ConcreteTemplate):
    key = globals()["ulonglong_iput"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(ulonglong_iput, types.Function(_typing_ulonglong_iput))


@register
class _typing_int8_iput(ConcreteTemplate):
    key = globals()["int8_iput"]
    cases = [signature(void, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)]

register_global(int8_iput, types.Function(_typing_int8_iput))


@register
class _typing_int16_iput(ConcreteTemplate):
    key = globals()["int16_iput"]
    cases = [signature(void, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)]

register_global(int16_iput, types.Function(_typing_int16_iput))


@register
class _typing_int32_iput(ConcreteTemplate):
    key = globals()["int32_iput"]
    cases = [signature(void, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)]

register_global(int32_iput, types.Function(_typing_int32_iput))


@register
class _typing_int64_iput(ConcreteTemplate):
    key = globals()["int64_iput"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(int64_iput, types.Function(_typing_int64_iput))


@register
class _typing_uint8_iput(ConcreteTemplate):
    key = globals()["uint8_iput"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)]

register_global(uint8_iput, types.Function(_typing_uint8_iput))


@register
class _typing_uint16_iput(ConcreteTemplate):
    key = globals()["uint16_iput"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)]

register_global(uint16_iput, types.Function(_typing_uint16_iput))


@register
class _typing_uint32_iput(ConcreteTemplate):
    key = globals()["uint32_iput"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)]

register_global(uint32_iput, types.Function(_typing_uint32_iput))


@register
class _typing_uint64_iput(ConcreteTemplate):
    key = globals()["uint64_iput"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(uint64_iput, types.Function(_typing_uint64_iput))


@register
class _typing_size_iput(ConcreteTemplate):
    key = globals()["size_iput"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(size_iput, types.Function(_typing_size_iput))


@register
class _typing_ptrdiff_iput(ConcreteTemplate):
    key = globals()["ptrdiff_iput"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(ptrdiff_iput, types.Function(_typing_ptrdiff_iput))


@register
class _typing_iput8(ConcreteTemplate):
    key = globals()["iput8"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iput8, types.Function(_typing_iput8))


@register
class _typing_iput16(ConcreteTemplate):
    key = globals()["iput16"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iput16, types.Function(_typing_iput16))


@register
class _typing_iput32(ConcreteTemplate):
    key = globals()["iput32"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iput32, types.Function(_typing_iput32))


@register
class _typing_iput64(ConcreteTemplate):
    key = globals()["iput64"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iput64, types.Function(_typing_iput64))


@register
class _typing_iput128(ConcreteTemplate):
    key = globals()["iput128"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iput128, types.Function(_typing_iput128))


@register
class _typing_bfloat16_iget(ConcreteTemplate):
    key = globals()["bfloat16_iget"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), int64, int64, uint64, int32)]

register_global(bfloat16_iget, types.Function(_typing_bfloat16_iget))


@register
class _typing_half_iget(ConcreteTemplate):
    key = globals()["half_iget"]
    cases = [signature(void, CPointer(float16), CPointer(float16), int64, int64, uint64, int32)]

register_global(half_iget, types.Function(_typing_half_iget))


@register
class _typing_float_iget(ConcreteTemplate):
    key = globals()["float_iget"]
    cases = [signature(void, CPointer(float32), CPointer(float32), int64, int64, uint64, int32)]

register_global(float_iget, types.Function(_typing_float_iget))


@register
class _typing_double_iget(ConcreteTemplate):
    key = globals()["double_iget"]
    cases = [signature(void, CPointer(float64), CPointer(float64), int64, int64, uint64, int32)]

register_global(double_iget, types.Function(_typing_double_iget))


@register
class _typing_char_iget(ConcreteTemplate):
    key = globals()["char_iget"]
    cases = [signature(void, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)]

register_global(char_iget, types.Function(_typing_char_iget))


@register
class _typing_short_iget(ConcreteTemplate):
    key = globals()["short_iget"]
    cases = [signature(void, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)]

register_global(short_iget, types.Function(_typing_short_iget))


@register
class _typing_schar_iget(ConcreteTemplate):
    key = globals()["schar_iget"]
    cases = [signature(void, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)]

register_global(schar_iget, types.Function(_typing_schar_iget))


@register
class _typing_int_iget(ConcreteTemplate):
    key = globals()["int_iget"]
    cases = [signature(void, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)]

register_global(int_iget, types.Function(_typing_int_iget))


@register
class _typing_long_iget(ConcreteTemplate):
    key = globals()["long_iget"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(long_iget, types.Function(_typing_long_iget))


@register
class _typing_longlong_iget(ConcreteTemplate):
    key = globals()["longlong_iget"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(longlong_iget, types.Function(_typing_longlong_iget))


@register
class _typing_uchar_iget(ConcreteTemplate):
    key = globals()["uchar_iget"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)]

register_global(uchar_iget, types.Function(_typing_uchar_iget))


@register
class _typing_ushort_iget(ConcreteTemplate):
    key = globals()["ushort_iget"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)]

register_global(ushort_iget, types.Function(_typing_ushort_iget))


@register
class _typing_uint_iget(ConcreteTemplate):
    key = globals()["uint_iget"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)]

register_global(uint_iget, types.Function(_typing_uint_iget))


@register
class _typing_ulong_iget(ConcreteTemplate):
    key = globals()["ulong_iget"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(ulong_iget, types.Function(_typing_ulong_iget))


@register
class _typing_ulonglong_iget(ConcreteTemplate):
    key = globals()["ulonglong_iget"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(ulonglong_iget, types.Function(_typing_ulonglong_iget))


@register
class _typing_int8_iget(ConcreteTemplate):
    key = globals()["int8_iget"]
    cases = [signature(void, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)]

register_global(int8_iget, types.Function(_typing_int8_iget))


@register
class _typing_int16_iget(ConcreteTemplate):
    key = globals()["int16_iget"]
    cases = [signature(void, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)]

register_global(int16_iget, types.Function(_typing_int16_iget))


@register
class _typing_int32_iget(ConcreteTemplate):
    key = globals()["int32_iget"]
    cases = [signature(void, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)]

register_global(int32_iget, types.Function(_typing_int32_iget))


@register
class _typing_int64_iget(ConcreteTemplate):
    key = globals()["int64_iget"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(int64_iget, types.Function(_typing_int64_iget))


@register
class _typing_uint8_iget(ConcreteTemplate):
    key = globals()["uint8_iget"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)]

register_global(uint8_iget, types.Function(_typing_uint8_iget))


@register
class _typing_uint16_iget(ConcreteTemplate):
    key = globals()["uint16_iget"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)]

register_global(uint16_iget, types.Function(_typing_uint16_iget))


@register
class _typing_uint32_iget(ConcreteTemplate):
    key = globals()["uint32_iget"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)]

register_global(uint32_iget, types.Function(_typing_uint32_iget))


@register
class _typing_uint64_iget(ConcreteTemplate):
    key = globals()["uint64_iget"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(uint64_iget, types.Function(_typing_uint64_iget))


@register
class _typing_size_iget(ConcreteTemplate):
    key = globals()["size_iget"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(size_iget, types.Function(_typing_size_iget))


@register
class _typing_ptrdiff_iget(ConcreteTemplate):
    key = globals()["ptrdiff_iget"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(ptrdiff_iget, types.Function(_typing_ptrdiff_iget))


@register
class _typing_iget8(ConcreteTemplate):
    key = globals()["iget8"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iget8, types.Function(_typing_iget8))


@register
class _typing_iget16(ConcreteTemplate):
    key = globals()["iget16"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iget16, types.Function(_typing_iget16))


@register
class _typing_iget32(ConcreteTemplate):
    key = globals()["iget32"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iget32, types.Function(_typing_iget32))


@register
class _typing_iget64(ConcreteTemplate):
    key = globals()["iget64"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iget64, types.Function(_typing_iget64))


@register
class _typing_iget128(ConcreteTemplate):
    key = globals()["iget128"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iget128, types.Function(_typing_iget128))


@register
class _typing_short_test(ConcreteTemplate):
    key = globals()["short_test"]
    cases = [signature(int32, CPointer(int16), int32, int16)]

register_global(short_test, types.Function(_typing_short_test))


@register
class _typing_int_test(ConcreteTemplate):
    key = globals()["int_test"]
    cases = [signature(int32, CPointer(int32), int32, int32)]

register_global(int_test, types.Function(_typing_int_test))


@register
class _typing_long_test(ConcreteTemplate):
    key = globals()["long_test"]
    cases = [signature(int32, CPointer(int64), int32, int64)]

register_global(long_test, types.Function(_typing_long_test))


@register
class _typing_longlong_test(ConcreteTemplate):
    key = globals()["longlong_test"]
    cases = [signature(int32, CPointer(int64), int32, int64)]

register_global(longlong_test, types.Function(_typing_longlong_test))


@register
class _typing_ushort_test(ConcreteTemplate):
    key = globals()["ushort_test"]
    cases = [signature(int32, CPointer(uint16), int32, uint16)]

register_global(ushort_test, types.Function(_typing_ushort_test))


@register
class _typing_uint_test(ConcreteTemplate):
    key = globals()["uint_test"]
    cases = [signature(int32, CPointer(uint32), int32, uint32)]

register_global(uint_test, types.Function(_typing_uint_test))


@register
class _typing_ulong_test(ConcreteTemplate):
    key = globals()["ulong_test"]
    cases = [signature(int32, CPointer(uint64), int32, uint64)]

register_global(ulong_test, types.Function(_typing_ulong_test))


@register
class _typing_ulonglong_test(ConcreteTemplate):
    key = globals()["ulonglong_test"]
    cases = [signature(int32, CPointer(uint64), int32, uint64)]

register_global(ulonglong_test, types.Function(_typing_ulonglong_test))


@register
class _typing_int32_test(ConcreteTemplate):
    key = globals()["int32_test"]
    cases = [signature(int32, CPointer(int32), int32, int32)]

register_global(int32_test, types.Function(_typing_int32_test))


@register
class _typing_int64_test(ConcreteTemplate):
    key = globals()["int64_test"]
    cases = [signature(int32, CPointer(int64), int32, int64)]

register_global(int64_test, types.Function(_typing_int64_test))


@register
class _typing_uint32_test(ConcreteTemplate):
    key = globals()["uint32_test"]
    cases = [signature(int32, CPointer(uint32), int32, uint32)]

register_global(uint32_test, types.Function(_typing_uint32_test))


@register
class _typing_uint64_test(ConcreteTemplate):
    key = globals()["uint64_test"]
    cases = [signature(int32, CPointer(uint64), int32, uint64)]

register_global(uint64_test, types.Function(_typing_uint64_test))


@register
class _typing_size_test(ConcreteTemplate):
    key = globals()["size_test"]
    cases = [signature(int32, CPointer(uint64), int32, uint64)]

register_global(size_test, types.Function(_typing_size_test))


@register
class _typing_ptrdiff_test(ConcreteTemplate):
    key = globals()["ptrdiff_test"]
    cases = [signature(int32, CPointer(int64), int32, int64)]

register_global(ptrdiff_test, types.Function(_typing_ptrdiff_test))


@register
class _typing_short_test_all(ConcreteTemplate):
    key = globals()["short_test_all"]
    cases = [signature(int32, CPointer(int16), uint64, CPointer(int32), int32, int16)]

register_global(short_test_all, types.Function(_typing_short_test_all))


@register
class _typing_int_test_all(ConcreteTemplate):
    key = globals()["int_test_all"]
    cases = [signature(int32, CPointer(int32), uint64, CPointer(int32), int32, int32)]

register_global(int_test_all, types.Function(_typing_int_test_all))


@register
class _typing_long_test_all(ConcreteTemplate):
    key = globals()["long_test_all"]
    cases = [signature(int32, CPointer(int64), uint64, CPointer(int32), int32, int64)]

register_global(long_test_all, types.Function(_typing_long_test_all))


@register
class _typing_longlong_test_all(ConcreteTemplate):
    key = globals()["longlong_test_all"]
    cases = [signature(int32, CPointer(int64), uint64, CPointer(int32), int32, int64)]

register_global(longlong_test_all, types.Function(_typing_longlong_test_all))


@register
class _typing_ushort_test_all(ConcreteTemplate):
    key = globals()["ushort_test_all"]
    cases = [signature(int32, CPointer(uint16), uint64, CPointer(int32), int32, uint16)]

register_global(ushort_test_all, types.Function(_typing_ushort_test_all))


@register
class _typing_uint_test_all(ConcreteTemplate):
    key = globals()["uint_test_all"]
    cases = [signature(int32, CPointer(uint32), uint64, CPointer(int32), int32, uint32)]

register_global(uint_test_all, types.Function(_typing_uint_test_all))


@register
class _typing_ulong_test_all(ConcreteTemplate):
    key = globals()["ulong_test_all"]
    cases = [signature(int32, CPointer(uint64), uint64, CPointer(int32), int32, uint64)]

register_global(ulong_test_all, types.Function(_typing_ulong_test_all))


@register
class _typing_ulonglong_test_all(ConcreteTemplate):
    key = globals()["ulonglong_test_all"]
    cases = [signature(int32, CPointer(uint64), uint64, CPointer(int32), int32, uint64)]

register_global(ulonglong_test_all, types.Function(_typing_ulonglong_test_all))


@register
class _typing_int32_test_all(ConcreteTemplate):
    key = globals()["int32_test_all"]
    cases = [signature(int32, CPointer(int32), uint64, CPointer(int32), int32, int32)]

register_global(int32_test_all, types.Function(_typing_int32_test_all))


@register
class _typing_int64_test_all(ConcreteTemplate):
    key = globals()["int64_test_all"]
    cases = [signature(int32, CPointer(int64), uint64, CPointer(int32), int32, int64)]

register_global(int64_test_all, types.Function(_typing_int64_test_all))


@register
class _typing_uint32_test_all(ConcreteTemplate):
    key = globals()["uint32_test_all"]
    cases = [signature(int32, CPointer(uint32), uint64, CPointer(int32), int32, uint32)]

register_global(uint32_test_all, types.Function(_typing_uint32_test_all))


@register
class _typing_uint64_test_all(ConcreteTemplate):
    key = globals()["uint64_test_all"]
    cases = [signature(int32, CPointer(uint64), uint64, CPointer(int32), int32, uint64)]

register_global(uint64_test_all, types.Function(_typing_uint64_test_all))


@register
class _typing_size_test_all(ConcreteTemplate):
    key = globals()["size_test_all"]
    cases = [signature(int32, CPointer(uint64), uint64, CPointer(int32), int32, uint64)]

register_global(size_test_all, types.Function(_typing_size_test_all))


@register
class _typing_ptrdiff_test_all(ConcreteTemplate):
    key = globals()["ptrdiff_test_all"]
    cases = [signature(int32, CPointer(int64), uint64, CPointer(int32), int32, int64)]

register_global(ptrdiff_test_all, types.Function(_typing_ptrdiff_test_all))


@register
class _typing_short_test_any(ConcreteTemplate):
    key = globals()["short_test_any"]
    cases = [signature(uint64, CPointer(int16), uint64, CPointer(int32), int32, int16)]

register_global(short_test_any, types.Function(_typing_short_test_any))


@register
class _typing_int_test_any(ConcreteTemplate):
    key = globals()["int_test_any"]
    cases = [signature(uint64, CPointer(int32), uint64, CPointer(int32), int32, int32)]

register_global(int_test_any, types.Function(_typing_int_test_any))


@register
class _typing_long_test_any(ConcreteTemplate):
    key = globals()["long_test_any"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(int32), int32, int64)]

register_global(long_test_any, types.Function(_typing_long_test_any))


@register
class _typing_longlong_test_any(ConcreteTemplate):
    key = globals()["longlong_test_any"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(int32), int32, int64)]

register_global(longlong_test_any, types.Function(_typing_longlong_test_any))


@register
class _typing_ushort_test_any(ConcreteTemplate):
    key = globals()["ushort_test_any"]
    cases = [signature(uint64, CPointer(uint16), uint64, CPointer(int32), int32, uint16)]

register_global(ushort_test_any, types.Function(_typing_ushort_test_any))


@register
class _typing_uint_test_any(ConcreteTemplate):
    key = globals()["uint_test_any"]
    cases = [signature(uint64, CPointer(uint32), uint64, CPointer(int32), int32, uint32)]

register_global(uint_test_any, types.Function(_typing_uint_test_any))


@register
class _typing_ulong_test_any(ConcreteTemplate):
    key = globals()["ulong_test_any"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(int32), int32, uint64)]

register_global(ulong_test_any, types.Function(_typing_ulong_test_any))


@register
class _typing_ulonglong_test_any(ConcreteTemplate):
    key = globals()["ulonglong_test_any"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(int32), int32, uint64)]

register_global(ulonglong_test_any, types.Function(_typing_ulonglong_test_any))


@register
class _typing_int32_test_any(ConcreteTemplate):
    key = globals()["int32_test_any"]
    cases = [signature(uint64, CPointer(int32), uint64, CPointer(int32), int32, int32)]

register_global(int32_test_any, types.Function(_typing_int32_test_any))


@register
class _typing_int64_test_any(ConcreteTemplate):
    key = globals()["int64_test_any"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(int32), int32, int64)]

register_global(int64_test_any, types.Function(_typing_int64_test_any))


@register
class _typing_uint32_test_any(ConcreteTemplate):
    key = globals()["uint32_test_any"]
    cases = [signature(uint64, CPointer(uint32), uint64, CPointer(int32), int32, uint32)]

register_global(uint32_test_any, types.Function(_typing_uint32_test_any))


@register
class _typing_uint64_test_any(ConcreteTemplate):
    key = globals()["uint64_test_any"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(int32), int32, uint64)]

register_global(uint64_test_any, types.Function(_typing_uint64_test_any))


@register
class _typing_size_test_any(ConcreteTemplate):
    key = globals()["size_test_any"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(int32), int32, uint64)]

register_global(size_test_any, types.Function(_typing_size_test_any))


@register
class _typing_ptrdiff_test_any(ConcreteTemplate):
    key = globals()["ptrdiff_test_any"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(int32), int32, int64)]

register_global(ptrdiff_test_any, types.Function(_typing_ptrdiff_test_any))


@register
class _typing_short_test_some(ConcreteTemplate):
    key = globals()["short_test_some"]
    cases = [signature(uint64, CPointer(int16), uint64, CPointer(uint64), CPointer(int32), int32, int16)]

register_global(short_test_some, types.Function(_typing_short_test_some))


@register
class _typing_int_test_some(ConcreteTemplate):
    key = globals()["int_test_some"]
    cases = [signature(uint64, CPointer(int32), uint64, CPointer(uint64), CPointer(int32), int32, int32)]

register_global(int_test_some, types.Function(_typing_int_test_some))


@register
class _typing_long_test_some(ConcreteTemplate):
    key = globals()["long_test_some"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, int64)]

register_global(long_test_some, types.Function(_typing_long_test_some))


@register
class _typing_longlong_test_some(ConcreteTemplate):
    key = globals()["longlong_test_some"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, int64)]

register_global(longlong_test_some, types.Function(_typing_longlong_test_some))


@register
class _typing_ushort_test_some(ConcreteTemplate):
    key = globals()["ushort_test_some"]
    cases = [signature(uint64, CPointer(uint16), uint64, CPointer(uint64), CPointer(int32), int32, uint16)]

register_global(ushort_test_some, types.Function(_typing_ushort_test_some))


@register
class _typing_uint_test_some(ConcreteTemplate):
    key = globals()["uint_test_some"]
    cases = [signature(uint64, CPointer(uint32), uint64, CPointer(uint64), CPointer(int32), int32, uint32)]

register_global(uint_test_some, types.Function(_typing_uint_test_some))


@register
class _typing_ulong_test_some(ConcreteTemplate):
    key = globals()["ulong_test_some"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, uint64)]

register_global(ulong_test_some, types.Function(_typing_ulong_test_some))


@register
class _typing_ulonglong_test_some(ConcreteTemplate):
    key = globals()["ulonglong_test_some"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, uint64)]

register_global(ulonglong_test_some, types.Function(_typing_ulonglong_test_some))


@register
class _typing_int32_test_some(ConcreteTemplate):
    key = globals()["int32_test_some"]
    cases = [signature(uint64, CPointer(int32), uint64, CPointer(uint64), CPointer(int32), int32, int32)]

register_global(int32_test_some, types.Function(_typing_int32_test_some))


@register
class _typing_int64_test_some(ConcreteTemplate):
    key = globals()["int64_test_some"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, int64)]

register_global(int64_test_some, types.Function(_typing_int64_test_some))


@register
class _typing_uint32_test_some(ConcreteTemplate):
    key = globals()["uint32_test_some"]
    cases = [signature(uint64, CPointer(uint32), uint64, CPointer(uint64), CPointer(int32), int32, uint32)]

register_global(uint32_test_some, types.Function(_typing_uint32_test_some))


@register
class _typing_uint64_test_some(ConcreteTemplate):
    key = globals()["uint64_test_some"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, uint64)]

register_global(uint64_test_some, types.Function(_typing_uint64_test_some))


@register
class _typing_size_test_some(ConcreteTemplate):
    key = globals()["size_test_some"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, uint64)]

register_global(size_test_some, types.Function(_typing_size_test_some))


@register
class _typing_ptrdiff_test_some(ConcreteTemplate):
    key = globals()["ptrdiff_test_some"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, int64)]

register_global(ptrdiff_test_some, types.Function(_typing_ptrdiff_test_some))


@register
class _typing_short_test_all_vector(ConcreteTemplate):
    key = globals()["short_test_all_vector"]
    cases = [signature(int32, CPointer(int16), uint64, CPointer(int32), int32, CPointer(int16))]

register_global(short_test_all_vector, types.Function(_typing_short_test_all_vector))


@register
class _typing_int_test_all_vector(ConcreteTemplate):
    key = globals()["int_test_all_vector"]
    cases = [signature(int32, CPointer(int32), uint64, CPointer(int32), int32, CPointer(int32))]

register_global(int_test_all_vector, types.Function(_typing_int_test_all_vector))


@register
class _typing_long_test_all_vector(ConcreteTemplate):
    key = globals()["long_test_all_vector"]
    cases = [signature(int32, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))]

register_global(long_test_all_vector, types.Function(_typing_long_test_all_vector))


@register
class _typing_longlong_test_all_vector(ConcreteTemplate):
    key = globals()["longlong_test_all_vector"]
    cases = [signature(int32, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))]

register_global(longlong_test_all_vector, types.Function(_typing_longlong_test_all_vector))


@register
class _typing_ushort_test_all_vector(ConcreteTemplate):
    key = globals()["ushort_test_all_vector"]
    cases = [signature(int32, CPointer(uint16), uint64, CPointer(int32), int32, CPointer(uint16))]

register_global(ushort_test_all_vector, types.Function(_typing_ushort_test_all_vector))


@register
class _typing_uint_test_all_vector(ConcreteTemplate):
    key = globals()["uint_test_all_vector"]
    cases = [signature(int32, CPointer(uint32), uint64, CPointer(int32), int32, CPointer(uint32))]

register_global(uint_test_all_vector, types.Function(_typing_uint_test_all_vector))


@register
class _typing_ulong_test_all_vector(ConcreteTemplate):
    key = globals()["ulong_test_all_vector"]
    cases = [signature(int32, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))]

register_global(ulong_test_all_vector, types.Function(_typing_ulong_test_all_vector))


@register
class _typing_ulonglong_test_all_vector(ConcreteTemplate):
    key = globals()["ulonglong_test_all_vector"]
    cases = [signature(int32, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))]

register_global(ulonglong_test_all_vector, types.Function(_typing_ulonglong_test_all_vector))


@register
class _typing_int32_test_all_vector(ConcreteTemplate):
    key = globals()["int32_test_all_vector"]
    cases = [signature(int32, CPointer(int32), uint64, CPointer(int32), int32, CPointer(int32))]

register_global(int32_test_all_vector, types.Function(_typing_int32_test_all_vector))


@register
class _typing_int64_test_all_vector(ConcreteTemplate):
    key = globals()["int64_test_all_vector"]
    cases = [signature(int32, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))]

register_global(int64_test_all_vector, types.Function(_typing_int64_test_all_vector))


@register
class _typing_uint32_test_all_vector(ConcreteTemplate):
    key = globals()["uint32_test_all_vector"]
    cases = [signature(int32, CPointer(uint32), uint64, CPointer(int32), int32, CPointer(uint32))]

register_global(uint32_test_all_vector, types.Function(_typing_uint32_test_all_vector))


@register
class _typing_uint64_test_all_vector(ConcreteTemplate):
    key = globals()["uint64_test_all_vector"]
    cases = [signature(int32, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))]

register_global(uint64_test_all_vector, types.Function(_typing_uint64_test_all_vector))


@register
class _typing_size_test_all_vector(ConcreteTemplate):
    key = globals()["size_test_all_vector"]
    cases = [signature(int32, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))]

register_global(size_test_all_vector, types.Function(_typing_size_test_all_vector))


@register
class _typing_ptrdiff_test_all_vector(ConcreteTemplate):
    key = globals()["ptrdiff_test_all_vector"]
    cases = [signature(int32, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))]

register_global(ptrdiff_test_all_vector, types.Function(_typing_ptrdiff_test_all_vector))


@register
class _typing_short_test_any_vector(ConcreteTemplate):
    key = globals()["short_test_any_vector"]
    cases = [signature(uint64, CPointer(int16), uint64, CPointer(int32), int32, CPointer(int16))]

register_global(short_test_any_vector, types.Function(_typing_short_test_any_vector))


@register
class _typing_int_test_any_vector(ConcreteTemplate):
    key = globals()["int_test_any_vector"]
    cases = [signature(uint64, CPointer(int32), uint64, CPointer(int32), int32, CPointer(int32))]

register_global(int_test_any_vector, types.Function(_typing_int_test_any_vector))


@register
class _typing_long_test_any_vector(ConcreteTemplate):
    key = globals()["long_test_any_vector"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))]

register_global(long_test_any_vector, types.Function(_typing_long_test_any_vector))


@register
class _typing_longlong_test_any_vector(ConcreteTemplate):
    key = globals()["longlong_test_any_vector"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))]

register_global(longlong_test_any_vector, types.Function(_typing_longlong_test_any_vector))


@register
class _typing_ushort_test_any_vector(ConcreteTemplate):
    key = globals()["ushort_test_any_vector"]
    cases = [signature(uint64, CPointer(uint16), uint64, CPointer(int32), int32, CPointer(uint16))]

register_global(ushort_test_any_vector, types.Function(_typing_ushort_test_any_vector))


@register
class _typing_uint_test_any_vector(ConcreteTemplate):
    key = globals()["uint_test_any_vector"]
    cases = [signature(uint64, CPointer(uint32), uint64, CPointer(int32), int32, CPointer(uint32))]

register_global(uint_test_any_vector, types.Function(_typing_uint_test_any_vector))


@register
class _typing_ulong_test_any_vector(ConcreteTemplate):
    key = globals()["ulong_test_any_vector"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))]

register_global(ulong_test_any_vector, types.Function(_typing_ulong_test_any_vector))


@register
class _typing_ulonglong_test_any_vector(ConcreteTemplate):
    key = globals()["ulonglong_test_any_vector"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))]

register_global(ulonglong_test_any_vector, types.Function(_typing_ulonglong_test_any_vector))


@register
class _typing_int32_test_any_vector(ConcreteTemplate):
    key = globals()["int32_test_any_vector"]
    cases = [signature(uint64, CPointer(int32), uint64, CPointer(int32), int32, CPointer(int32))]

register_global(int32_test_any_vector, types.Function(_typing_int32_test_any_vector))


@register
class _typing_int64_test_any_vector(ConcreteTemplate):
    key = globals()["int64_test_any_vector"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))]

register_global(int64_test_any_vector, types.Function(_typing_int64_test_any_vector))


@register
class _typing_uint32_test_any_vector(ConcreteTemplate):
    key = globals()["uint32_test_any_vector"]
    cases = [signature(uint64, CPointer(uint32), uint64, CPointer(int32), int32, CPointer(uint32))]

register_global(uint32_test_any_vector, types.Function(_typing_uint32_test_any_vector))


@register
class _typing_uint64_test_any_vector(ConcreteTemplate):
    key = globals()["uint64_test_any_vector"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))]

register_global(uint64_test_any_vector, types.Function(_typing_uint64_test_any_vector))


@register
class _typing_size_test_any_vector(ConcreteTemplate):
    key = globals()["size_test_any_vector"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))]

register_global(size_test_any_vector, types.Function(_typing_size_test_any_vector))


@register
class _typing_ptrdiff_test_any_vector(ConcreteTemplate):
    key = globals()["ptrdiff_test_any_vector"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))]

register_global(ptrdiff_test_any_vector, types.Function(_typing_ptrdiff_test_any_vector))


@register
class _typing_short_test_some_vector(ConcreteTemplate):
    key = globals()["short_test_some_vector"]
    cases = [signature(uint64, CPointer(int16), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int16))]

register_global(short_test_some_vector, types.Function(_typing_short_test_some_vector))


@register
class _typing_int_test_some_vector(ConcreteTemplate):
    key = globals()["int_test_some_vector"]
    cases = [signature(uint64, CPointer(int32), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int32))]

register_global(int_test_some_vector, types.Function(_typing_int_test_some_vector))


@register
class _typing_long_test_some_vector(ConcreteTemplate):
    key = globals()["long_test_some_vector"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int64))]

register_global(long_test_some_vector, types.Function(_typing_long_test_some_vector))


@register
class _typing_longlong_test_some_vector(ConcreteTemplate):
    key = globals()["longlong_test_some_vector"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int64))]

register_global(longlong_test_some_vector, types.Function(_typing_longlong_test_some_vector))


@register
class _typing_ushort_test_some_vector(ConcreteTemplate):
    key = globals()["ushort_test_some_vector"]
    cases = [signature(uint64, CPointer(uint16), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint16))]

register_global(ushort_test_some_vector, types.Function(_typing_ushort_test_some_vector))


@register
class _typing_uint_test_some_vector(ConcreteTemplate):
    key = globals()["uint_test_some_vector"]
    cases = [signature(uint64, CPointer(uint32), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint32))]

register_global(uint_test_some_vector, types.Function(_typing_uint_test_some_vector))


@register
class _typing_ulong_test_some_vector(ConcreteTemplate):
    key = globals()["ulong_test_some_vector"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint64))]

register_global(ulong_test_some_vector, types.Function(_typing_ulong_test_some_vector))


@register
class _typing_ulonglong_test_some_vector(ConcreteTemplate):
    key = globals()["ulonglong_test_some_vector"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint64))]

register_global(ulonglong_test_some_vector, types.Function(_typing_ulonglong_test_some_vector))


@register
class _typing_int32_test_some_vector(ConcreteTemplate):
    key = globals()["int32_test_some_vector"]
    cases = [signature(uint64, CPointer(int32), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int32))]

register_global(int32_test_some_vector, types.Function(_typing_int32_test_some_vector))


@register
class _typing_int64_test_some_vector(ConcreteTemplate):
    key = globals()["int64_test_some_vector"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int64))]

register_global(int64_test_some_vector, types.Function(_typing_int64_test_some_vector))


@register
class _typing_uint32_test_some_vector(ConcreteTemplate):
    key = globals()["uint32_test_some_vector"]
    cases = [signature(uint64, CPointer(uint32), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint32))]

register_global(uint32_test_some_vector, types.Function(_typing_uint32_test_some_vector))


@register
class _typing_uint64_test_some_vector(ConcreteTemplate):
    key = globals()["uint64_test_some_vector"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint64))]

register_global(uint64_test_some_vector, types.Function(_typing_uint64_test_some_vector))


@register
class _typing_size_test_some_vector(ConcreteTemplate):
    key = globals()["size_test_some_vector"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint64))]

register_global(size_test_some_vector, types.Function(_typing_size_test_some_vector))


@register
class _typing_ptrdiff_test_some_vector(ConcreteTemplate):
    key = globals()["ptrdiff_test_some_vector"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int64))]

register_global(ptrdiff_test_some_vector, types.Function(_typing_ptrdiff_test_some_vector))


@register
class _typing_short_wait_until(ConcreteTemplate):
    key = globals()["short_wait_until"]
    cases = [signature(void, CPointer(int16), int32, int16)]

register_global(short_wait_until, types.Function(_typing_short_wait_until))


@register
class _typing_int_wait_until(ConcreteTemplate):
    key = globals()["int_wait_until"]
    cases = [signature(void, CPointer(int32), int32, int32)]

register_global(int_wait_until, types.Function(_typing_int_wait_until))


@register
class _typing_long_wait_until(ConcreteTemplate):
    key = globals()["long_wait_until"]
    cases = [signature(void, CPointer(int64), int32, int64)]

register_global(long_wait_until, types.Function(_typing_long_wait_until))


@register
class _typing_longlong_wait_until(ConcreteTemplate):
    key = globals()["longlong_wait_until"]
    cases = [signature(void, CPointer(int64), int32, int64)]

register_global(longlong_wait_until, types.Function(_typing_longlong_wait_until))


@register
class _typing_ushort_wait_until(ConcreteTemplate):
    key = globals()["ushort_wait_until"]
    cases = [signature(void, CPointer(uint16), int32, uint16)]

register_global(ushort_wait_until, types.Function(_typing_ushort_wait_until))


@register
class _typing_uint_wait_until(ConcreteTemplate):
    key = globals()["uint_wait_until"]
    cases = [signature(void, CPointer(uint32), int32, uint32)]

register_global(uint_wait_until, types.Function(_typing_uint_wait_until))


@register
class _typing_ulong_wait_until(ConcreteTemplate):
    key = globals()["ulong_wait_until"]
    cases = [signature(void, CPointer(uint64), int32, uint64)]

register_global(ulong_wait_until, types.Function(_typing_ulong_wait_until))


@register
class _typing_ulonglong_wait_until(ConcreteTemplate):
    key = globals()["ulonglong_wait_until"]
    cases = [signature(void, CPointer(uint64), int32, uint64)]

register_global(ulonglong_wait_until, types.Function(_typing_ulonglong_wait_until))


@register
class _typing_int32_wait_until(ConcreteTemplate):
    key = globals()["int32_wait_until"]
    cases = [signature(void, CPointer(int32), int32, int32)]

register_global(int32_wait_until, types.Function(_typing_int32_wait_until))


@register
class _typing_int64_wait_until(ConcreteTemplate):
    key = globals()["int64_wait_until"]
    cases = [signature(void, CPointer(int64), int32, int64)]

register_global(int64_wait_until, types.Function(_typing_int64_wait_until))


@register
class _typing_uint32_wait_until(ConcreteTemplate):
    key = globals()["uint32_wait_until"]
    cases = [signature(void, CPointer(uint32), int32, uint32)]

register_global(uint32_wait_until, types.Function(_typing_uint32_wait_until))


@register
class _typing_uint64_wait_until(ConcreteTemplate):
    key = globals()["uint64_wait_until"]
    cases = [signature(void, CPointer(uint64), int32, uint64)]

register_global(uint64_wait_until, types.Function(_typing_uint64_wait_until))


@register
class _typing_size_wait_until(ConcreteTemplate):
    key = globals()["size_wait_until"]
    cases = [signature(void, CPointer(uint64), int32, uint64)]

register_global(size_wait_until, types.Function(_typing_size_wait_until))


@register
class _typing_ptrdiff_wait_until(ConcreteTemplate):
    key = globals()["ptrdiff_wait_until"]
    cases = [signature(void, CPointer(int64), int32, int64)]

register_global(ptrdiff_wait_until, types.Function(_typing_ptrdiff_wait_until))


@register
class _typing_signal_fetch(ConcreteTemplate):
    key = globals()["signal_fetch"]
    cases = [signature(uint64, CPointer(uint64))]

register_global(signal_fetch, types.Function(_typing_signal_fetch))


@register
class _typing_signal_wait_until(ConcreteTemplate):
    key = globals()["signal_wait_until"]
    cases = [signature(uint64, CPointer(uint64), int32, uint64)]

register_global(signal_wait_until, types.Function(_typing_signal_wait_until))


@register
class _typing_short_wait_until_all(ConcreteTemplate):
    key = globals()["short_wait_until_all"]
    cases = [signature(void, CPointer(int16), uint64, CPointer(int32), int32, int16)]

register_global(short_wait_until_all, types.Function(_typing_short_wait_until_all))


@register
class _typing_int_wait_until_all(ConcreteTemplate):
    key = globals()["int_wait_until_all"]
    cases = [signature(void, CPointer(int32), uint64, CPointer(int32), int32, int32)]

register_global(int_wait_until_all, types.Function(_typing_int_wait_until_all))


@register
class _typing_long_wait_until_all(ConcreteTemplate):
    key = globals()["long_wait_until_all"]
    cases = [signature(void, CPointer(int64), uint64, CPointer(int32), int32, int64)]

register_global(long_wait_until_all, types.Function(_typing_long_wait_until_all))


@register
class _typing_longlong_wait_until_all(ConcreteTemplate):
    key = globals()["longlong_wait_until_all"]
    cases = [signature(void, CPointer(int64), uint64, CPointer(int32), int32, int64)]

register_global(longlong_wait_until_all, types.Function(_typing_longlong_wait_until_all))


@register
class _typing_ushort_wait_until_all(ConcreteTemplate):
    key = globals()["ushort_wait_until_all"]
    cases = [signature(void, CPointer(uint16), uint64, CPointer(int32), int32, uint16)]

register_global(ushort_wait_until_all, types.Function(_typing_ushort_wait_until_all))


@register
class _typing_uint_wait_until_all(ConcreteTemplate):
    key = globals()["uint_wait_until_all"]
    cases = [signature(void, CPointer(uint32), uint64, CPointer(int32), int32, uint32)]

register_global(uint_wait_until_all, types.Function(_typing_uint_wait_until_all))


@register
class _typing_ulong_wait_until_all(ConcreteTemplate):
    key = globals()["ulong_wait_until_all"]
    cases = [signature(void, CPointer(uint64), uint64, CPointer(int32), int32, uint64)]

register_global(ulong_wait_until_all, types.Function(_typing_ulong_wait_until_all))


@register
class _typing_ulonglong_wait_until_all(ConcreteTemplate):
    key = globals()["ulonglong_wait_until_all"]
    cases = [signature(void, CPointer(uint64), uint64, CPointer(int32), int32, uint64)]

register_global(ulonglong_wait_until_all, types.Function(_typing_ulonglong_wait_until_all))


@register
class _typing_int32_wait_until_all(ConcreteTemplate):
    key = globals()["int32_wait_until_all"]
    cases = [signature(void, CPointer(int32), uint64, CPointer(int32), int32, int32)]

register_global(int32_wait_until_all, types.Function(_typing_int32_wait_until_all))


@register
class _typing_int64_wait_until_all(ConcreteTemplate):
    key = globals()["int64_wait_until_all"]
    cases = [signature(void, CPointer(int64), uint64, CPointer(int32), int32, int64)]

register_global(int64_wait_until_all, types.Function(_typing_int64_wait_until_all))


@register
class _typing_uint32_wait_until_all(ConcreteTemplate):
    key = globals()["uint32_wait_until_all"]
    cases = [signature(void, CPointer(uint32), uint64, CPointer(int32), int32, uint32)]

register_global(uint32_wait_until_all, types.Function(_typing_uint32_wait_until_all))


@register
class _typing_uint64_wait_until_all(ConcreteTemplate):
    key = globals()["uint64_wait_until_all"]
    cases = [signature(void, CPointer(uint64), uint64, CPointer(int32), int32, uint64)]

register_global(uint64_wait_until_all, types.Function(_typing_uint64_wait_until_all))


@register
class _typing_size_wait_until_all(ConcreteTemplate):
    key = globals()["size_wait_until_all"]
    cases = [signature(void, CPointer(uint64), uint64, CPointer(int32), int32, uint64)]

register_global(size_wait_until_all, types.Function(_typing_size_wait_until_all))


@register
class _typing_ptrdiff_wait_until_all(ConcreteTemplate):
    key = globals()["ptrdiff_wait_until_all"]
    cases = [signature(void, CPointer(int64), uint64, CPointer(int32), int32, int64)]

register_global(ptrdiff_wait_until_all, types.Function(_typing_ptrdiff_wait_until_all))


@register
class _typing_short_wait_until_any(ConcreteTemplate):
    key = globals()["short_wait_until_any"]
    cases = [signature(uint64, CPointer(int16), uint64, CPointer(int32), int32, int16)]

register_global(short_wait_until_any, types.Function(_typing_short_wait_until_any))


@register
class _typing_int_wait_until_any(ConcreteTemplate):
    key = globals()["int_wait_until_any"]
    cases = [signature(uint64, CPointer(int32), uint64, CPointer(int32), int32, int32)]

register_global(int_wait_until_any, types.Function(_typing_int_wait_until_any))


@register
class _typing_long_wait_until_any(ConcreteTemplate):
    key = globals()["long_wait_until_any"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(int32), int32, int64)]

register_global(long_wait_until_any, types.Function(_typing_long_wait_until_any))


@register
class _typing_longlong_wait_until_any(ConcreteTemplate):
    key = globals()["longlong_wait_until_any"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(int32), int32, int64)]

register_global(longlong_wait_until_any, types.Function(_typing_longlong_wait_until_any))


@register
class _typing_ushort_wait_until_any(ConcreteTemplate):
    key = globals()["ushort_wait_until_any"]
    cases = [signature(uint64, CPointer(uint16), uint64, CPointer(int32), int32, uint16)]

register_global(ushort_wait_until_any, types.Function(_typing_ushort_wait_until_any))


@register
class _typing_uint_wait_until_any(ConcreteTemplate):
    key = globals()["uint_wait_until_any"]
    cases = [signature(uint64, CPointer(uint32), uint64, CPointer(int32), int32, uint32)]

register_global(uint_wait_until_any, types.Function(_typing_uint_wait_until_any))


@register
class _typing_ulong_wait_until_any(ConcreteTemplate):
    key = globals()["ulong_wait_until_any"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(int32), int32, uint64)]

register_global(ulong_wait_until_any, types.Function(_typing_ulong_wait_until_any))


@register
class _typing_ulonglong_wait_until_any(ConcreteTemplate):
    key = globals()["ulonglong_wait_until_any"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(int32), int32, uint64)]

register_global(ulonglong_wait_until_any, types.Function(_typing_ulonglong_wait_until_any))


@register
class _typing_int32_wait_until_any(ConcreteTemplate):
    key = globals()["int32_wait_until_any"]
    cases = [signature(uint64, CPointer(int32), uint64, CPointer(int32), int32, int32)]

register_global(int32_wait_until_any, types.Function(_typing_int32_wait_until_any))


@register
class _typing_int64_wait_until_any(ConcreteTemplate):
    key = globals()["int64_wait_until_any"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(int32), int32, int64)]

register_global(int64_wait_until_any, types.Function(_typing_int64_wait_until_any))


@register
class _typing_uint32_wait_until_any(ConcreteTemplate):
    key = globals()["uint32_wait_until_any"]
    cases = [signature(uint64, CPointer(uint32), uint64, CPointer(int32), int32, uint32)]

register_global(uint32_wait_until_any, types.Function(_typing_uint32_wait_until_any))


@register
class _typing_uint64_wait_until_any(ConcreteTemplate):
    key = globals()["uint64_wait_until_any"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(int32), int32, uint64)]

register_global(uint64_wait_until_any, types.Function(_typing_uint64_wait_until_any))


@register
class _typing_size_wait_until_any(ConcreteTemplate):
    key = globals()["size_wait_until_any"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(int32), int32, uint64)]

register_global(size_wait_until_any, types.Function(_typing_size_wait_until_any))


@register
class _typing_ptrdiff_wait_until_any(ConcreteTemplate):
    key = globals()["ptrdiff_wait_until_any"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(int32), int32, int64)]

register_global(ptrdiff_wait_until_any, types.Function(_typing_ptrdiff_wait_until_any))


@register
class _typing_short_wait_until_some(ConcreteTemplate):
    key = globals()["short_wait_until_some"]
    cases = [signature(uint64, CPointer(int16), uint64, CPointer(uint64), CPointer(int32), int32, int16)]

register_global(short_wait_until_some, types.Function(_typing_short_wait_until_some))


@register
class _typing_int_wait_until_some(ConcreteTemplate):
    key = globals()["int_wait_until_some"]
    cases = [signature(uint64, CPointer(int32), uint64, CPointer(uint64), CPointer(int32), int32, int32)]

register_global(int_wait_until_some, types.Function(_typing_int_wait_until_some))


@register
class _typing_long_wait_until_some(ConcreteTemplate):
    key = globals()["long_wait_until_some"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, int64)]

register_global(long_wait_until_some, types.Function(_typing_long_wait_until_some))


@register
class _typing_longlong_wait_until_some(ConcreteTemplate):
    key = globals()["longlong_wait_until_some"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, int64)]

register_global(longlong_wait_until_some, types.Function(_typing_longlong_wait_until_some))


@register
class _typing_ushort_wait_until_some(ConcreteTemplate):
    key = globals()["ushort_wait_until_some"]
    cases = [signature(uint64, CPointer(uint16), uint64, CPointer(uint64), CPointer(int32), int32, uint16)]

register_global(ushort_wait_until_some, types.Function(_typing_ushort_wait_until_some))


@register
class _typing_uint_wait_until_some(ConcreteTemplate):
    key = globals()["uint_wait_until_some"]
    cases = [signature(uint64, CPointer(uint32), uint64, CPointer(uint64), CPointer(int32), int32, uint32)]

register_global(uint_wait_until_some, types.Function(_typing_uint_wait_until_some))


@register
class _typing_ulong_wait_until_some(ConcreteTemplate):
    key = globals()["ulong_wait_until_some"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, uint64)]

register_global(ulong_wait_until_some, types.Function(_typing_ulong_wait_until_some))


@register
class _typing_ulonglong_wait_until_some(ConcreteTemplate):
    key = globals()["ulonglong_wait_until_some"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, uint64)]

register_global(ulonglong_wait_until_some, types.Function(_typing_ulonglong_wait_until_some))


@register
class _typing_int32_wait_until_some(ConcreteTemplate):
    key = globals()["int32_wait_until_some"]
    cases = [signature(uint64, CPointer(int32), uint64, CPointer(uint64), CPointer(int32), int32, int32)]

register_global(int32_wait_until_some, types.Function(_typing_int32_wait_until_some))


@register
class _typing_int64_wait_until_some(ConcreteTemplate):
    key = globals()["int64_wait_until_some"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, int64)]

register_global(int64_wait_until_some, types.Function(_typing_int64_wait_until_some))


@register
class _typing_uint32_wait_until_some(ConcreteTemplate):
    key = globals()["uint32_wait_until_some"]
    cases = [signature(uint64, CPointer(uint32), uint64, CPointer(uint64), CPointer(int32), int32, uint32)]

register_global(uint32_wait_until_some, types.Function(_typing_uint32_wait_until_some))


@register
class _typing_uint64_wait_until_some(ConcreteTemplate):
    key = globals()["uint64_wait_until_some"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, uint64)]

register_global(uint64_wait_until_some, types.Function(_typing_uint64_wait_until_some))


@register
class _typing_size_wait_until_some(ConcreteTemplate):
    key = globals()["size_wait_until_some"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, uint64)]

register_global(size_wait_until_some, types.Function(_typing_size_wait_until_some))


@register
class _typing_ptrdiff_wait_until_some(ConcreteTemplate):
    key = globals()["ptrdiff_wait_until_some"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, int64)]

register_global(ptrdiff_wait_until_some, types.Function(_typing_ptrdiff_wait_until_some))


@register
class _typing_short_wait_until_all_vector(ConcreteTemplate):
    key = globals()["short_wait_until_all_vector"]
    cases = [signature(void, CPointer(int16), uint64, CPointer(int32), int32, CPointer(int16))]

register_global(short_wait_until_all_vector, types.Function(_typing_short_wait_until_all_vector))


@register
class _typing_int_wait_until_all_vector(ConcreteTemplate):
    key = globals()["int_wait_until_all_vector"]
    cases = [signature(void, CPointer(int32), uint64, CPointer(int32), int32, CPointer(int32))]

register_global(int_wait_until_all_vector, types.Function(_typing_int_wait_until_all_vector))


@register
class _typing_long_wait_until_all_vector(ConcreteTemplate):
    key = globals()["long_wait_until_all_vector"]
    cases = [signature(void, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))]

register_global(long_wait_until_all_vector, types.Function(_typing_long_wait_until_all_vector))


@register
class _typing_longlong_wait_until_all_vector(ConcreteTemplate):
    key = globals()["longlong_wait_until_all_vector"]
    cases = [signature(void, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))]

register_global(longlong_wait_until_all_vector, types.Function(_typing_longlong_wait_until_all_vector))


@register
class _typing_ushort_wait_until_all_vector(ConcreteTemplate):
    key = globals()["ushort_wait_until_all_vector"]
    cases = [signature(void, CPointer(uint16), uint64, CPointer(int32), int32, CPointer(uint16))]

register_global(ushort_wait_until_all_vector, types.Function(_typing_ushort_wait_until_all_vector))


@register
class _typing_uint_wait_until_all_vector(ConcreteTemplate):
    key = globals()["uint_wait_until_all_vector"]
    cases = [signature(void, CPointer(uint32), uint64, CPointer(int32), int32, CPointer(uint32))]

register_global(uint_wait_until_all_vector, types.Function(_typing_uint_wait_until_all_vector))


@register
class _typing_ulong_wait_until_all_vector(ConcreteTemplate):
    key = globals()["ulong_wait_until_all_vector"]
    cases = [signature(void, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))]

register_global(ulong_wait_until_all_vector, types.Function(_typing_ulong_wait_until_all_vector))


@register
class _typing_ulonglong_wait_until_all_vector(ConcreteTemplate):
    key = globals()["ulonglong_wait_until_all_vector"]
    cases = [signature(void, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))]

register_global(ulonglong_wait_until_all_vector, types.Function(_typing_ulonglong_wait_until_all_vector))


@register
class _typing_int32_wait_until_all_vector(ConcreteTemplate):
    key = globals()["int32_wait_until_all_vector"]
    cases = [signature(void, CPointer(int32), uint64, CPointer(int32), int32, CPointer(int32))]

register_global(int32_wait_until_all_vector, types.Function(_typing_int32_wait_until_all_vector))


@register
class _typing_int64_wait_until_all_vector(ConcreteTemplate):
    key = globals()["int64_wait_until_all_vector"]
    cases = [signature(void, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))]

register_global(int64_wait_until_all_vector, types.Function(_typing_int64_wait_until_all_vector))


@register
class _typing_uint32_wait_until_all_vector(ConcreteTemplate):
    key = globals()["uint32_wait_until_all_vector"]
    cases = [signature(void, CPointer(uint32), uint64, CPointer(int32), int32, CPointer(uint32))]

register_global(uint32_wait_until_all_vector, types.Function(_typing_uint32_wait_until_all_vector))


@register
class _typing_uint64_wait_until_all_vector(ConcreteTemplate):
    key = globals()["uint64_wait_until_all_vector"]
    cases = [signature(void, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))]

register_global(uint64_wait_until_all_vector, types.Function(_typing_uint64_wait_until_all_vector))


@register
class _typing_size_wait_until_all_vector(ConcreteTemplate):
    key = globals()["size_wait_until_all_vector"]
    cases = [signature(void, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))]

register_global(size_wait_until_all_vector, types.Function(_typing_size_wait_until_all_vector))


@register
class _typing_ptrdiff_wait_until_all_vector(ConcreteTemplate):
    key = globals()["ptrdiff_wait_until_all_vector"]
    cases = [signature(void, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))]

register_global(ptrdiff_wait_until_all_vector, types.Function(_typing_ptrdiff_wait_until_all_vector))


@register
class _typing_short_wait_until_any_vector(ConcreteTemplate):
    key = globals()["short_wait_until_any_vector"]
    cases = [signature(uint64, CPointer(int16), uint64, CPointer(int32), int32, CPointer(int16))]

register_global(short_wait_until_any_vector, types.Function(_typing_short_wait_until_any_vector))


@register
class _typing_int_wait_until_any_vector(ConcreteTemplate):
    key = globals()["int_wait_until_any_vector"]
    cases = [signature(uint64, CPointer(int32), uint64, CPointer(int32), int32, CPointer(int32))]

register_global(int_wait_until_any_vector, types.Function(_typing_int_wait_until_any_vector))


@register
class _typing_long_wait_until_any_vector(ConcreteTemplate):
    key = globals()["long_wait_until_any_vector"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))]

register_global(long_wait_until_any_vector, types.Function(_typing_long_wait_until_any_vector))


@register
class _typing_longlong_wait_until_any_vector(ConcreteTemplate):
    key = globals()["longlong_wait_until_any_vector"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))]

register_global(longlong_wait_until_any_vector, types.Function(_typing_longlong_wait_until_any_vector))


@register
class _typing_ushort_wait_until_any_vector(ConcreteTemplate):
    key = globals()["ushort_wait_until_any_vector"]
    cases = [signature(uint64, CPointer(uint16), uint64, CPointer(int32), int32, CPointer(uint16))]

register_global(ushort_wait_until_any_vector, types.Function(_typing_ushort_wait_until_any_vector))


@register
class _typing_uint_wait_until_any_vector(ConcreteTemplate):
    key = globals()["uint_wait_until_any_vector"]
    cases = [signature(uint64, CPointer(uint32), uint64, CPointer(int32), int32, CPointer(uint32))]

register_global(uint_wait_until_any_vector, types.Function(_typing_uint_wait_until_any_vector))


@register
class _typing_ulong_wait_until_any_vector(ConcreteTemplate):
    key = globals()["ulong_wait_until_any_vector"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))]

register_global(ulong_wait_until_any_vector, types.Function(_typing_ulong_wait_until_any_vector))


@register
class _typing_ulonglong_wait_until_any_vector(ConcreteTemplate):
    key = globals()["ulonglong_wait_until_any_vector"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))]

register_global(ulonglong_wait_until_any_vector, types.Function(_typing_ulonglong_wait_until_any_vector))


@register
class _typing_int32_wait_until_any_vector(ConcreteTemplate):
    key = globals()["int32_wait_until_any_vector"]
    cases = [signature(uint64, CPointer(int32), uint64, CPointer(int32), int32, CPointer(int32))]

register_global(int32_wait_until_any_vector, types.Function(_typing_int32_wait_until_any_vector))


@register
class _typing_int64_wait_until_any_vector(ConcreteTemplate):
    key = globals()["int64_wait_until_any_vector"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))]

register_global(int64_wait_until_any_vector, types.Function(_typing_int64_wait_until_any_vector))


@register
class _typing_uint32_wait_until_any_vector(ConcreteTemplate):
    key = globals()["uint32_wait_until_any_vector"]
    cases = [signature(uint64, CPointer(uint32), uint64, CPointer(int32), int32, CPointer(uint32))]

register_global(uint32_wait_until_any_vector, types.Function(_typing_uint32_wait_until_any_vector))


@register
class _typing_uint64_wait_until_any_vector(ConcreteTemplate):
    key = globals()["uint64_wait_until_any_vector"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))]

register_global(uint64_wait_until_any_vector, types.Function(_typing_uint64_wait_until_any_vector))


@register
class _typing_size_wait_until_any_vector(ConcreteTemplate):
    key = globals()["size_wait_until_any_vector"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(int32), int32, CPointer(uint64))]

register_global(size_wait_until_any_vector, types.Function(_typing_size_wait_until_any_vector))


@register
class _typing_ptrdiff_wait_until_any_vector(ConcreteTemplate):
    key = globals()["ptrdiff_wait_until_any_vector"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(int32), int32, CPointer(int64))]

register_global(ptrdiff_wait_until_any_vector, types.Function(_typing_ptrdiff_wait_until_any_vector))


@register
class _typing_short_wait_until_some_vector(ConcreteTemplate):
    key = globals()["short_wait_until_some_vector"]
    cases = [signature(uint64, CPointer(int16), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int16))]

register_global(short_wait_until_some_vector, types.Function(_typing_short_wait_until_some_vector))


@register
class _typing_int_wait_until_some_vector(ConcreteTemplate):
    key = globals()["int_wait_until_some_vector"]
    cases = [signature(uint64, CPointer(int32), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int32))]

register_global(int_wait_until_some_vector, types.Function(_typing_int_wait_until_some_vector))


@register
class _typing_long_wait_until_some_vector(ConcreteTemplate):
    key = globals()["long_wait_until_some_vector"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int64))]

register_global(long_wait_until_some_vector, types.Function(_typing_long_wait_until_some_vector))


@register
class _typing_longlong_wait_until_some_vector(ConcreteTemplate):
    key = globals()["longlong_wait_until_some_vector"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int64))]

register_global(longlong_wait_until_some_vector, types.Function(_typing_longlong_wait_until_some_vector))


@register
class _typing_ushort_wait_until_some_vector(ConcreteTemplate):
    key = globals()["ushort_wait_until_some_vector"]
    cases = [signature(uint64, CPointer(uint16), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint16))]

register_global(ushort_wait_until_some_vector, types.Function(_typing_ushort_wait_until_some_vector))


@register
class _typing_uint_wait_until_some_vector(ConcreteTemplate):
    key = globals()["uint_wait_until_some_vector"]
    cases = [signature(uint64, CPointer(uint32), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint32))]

register_global(uint_wait_until_some_vector, types.Function(_typing_uint_wait_until_some_vector))


@register
class _typing_ulong_wait_until_some_vector(ConcreteTemplate):
    key = globals()["ulong_wait_until_some_vector"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint64))]

register_global(ulong_wait_until_some_vector, types.Function(_typing_ulong_wait_until_some_vector))


@register
class _typing_ulonglong_wait_until_some_vector(ConcreteTemplate):
    key = globals()["ulonglong_wait_until_some_vector"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint64))]

register_global(ulonglong_wait_until_some_vector, types.Function(_typing_ulonglong_wait_until_some_vector))


@register
class _typing_int32_wait_until_some_vector(ConcreteTemplate):
    key = globals()["int32_wait_until_some_vector"]
    cases = [signature(uint64, CPointer(int32), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int32))]

register_global(int32_wait_until_some_vector, types.Function(_typing_int32_wait_until_some_vector))


@register
class _typing_int64_wait_until_some_vector(ConcreteTemplate):
    key = globals()["int64_wait_until_some_vector"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int64))]

register_global(int64_wait_until_some_vector, types.Function(_typing_int64_wait_until_some_vector))


@register
class _typing_uint32_wait_until_some_vector(ConcreteTemplate):
    key = globals()["uint32_wait_until_some_vector"]
    cases = [signature(uint64, CPointer(uint32), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint32))]

register_global(uint32_wait_until_some_vector, types.Function(_typing_uint32_wait_until_some_vector))


@register
class _typing_uint64_wait_until_some_vector(ConcreteTemplate):
    key = globals()["uint64_wait_until_some_vector"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint64))]

register_global(uint64_wait_until_some_vector, types.Function(_typing_uint64_wait_until_some_vector))


@register
class _typing_size_wait_until_some_vector(ConcreteTemplate):
    key = globals()["size_wait_until_some_vector"]
    cases = [signature(uint64, CPointer(uint64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(uint64))]

register_global(size_wait_until_some_vector, types.Function(_typing_size_wait_until_some_vector))


@register
class _typing_ptrdiff_wait_until_some_vector(ConcreteTemplate):
    key = globals()["ptrdiff_wait_until_some_vector"]
    cases = [signature(uint64, CPointer(int64), uint64, CPointer(uint64), CPointer(int32), int32, CPointer(int64))]

register_global(ptrdiff_wait_until_some_vector, types.Function(_typing_ptrdiff_wait_until_some_vector))


@register
class _typing_quiet(ConcreteTemplate):
    key = globals()["quiet"]
    cases = [signature(void, )]

register_global(quiet, types.Function(_typing_quiet))


@register
class _typing_fence(ConcreteTemplate):
    key = globals()["fence"]
    cases = [signature(void, )]

register_global(fence, types.Function(_typing_fence))


@register
class _typing_int_atomic_fetch_add(ConcreteTemplate):
    key = globals()["int_atomic_fetch_add"]
    cases = [signature(int32, CPointer(int32), int32, int32)]

register_global(int_atomic_fetch_add, types.Function(_typing_int_atomic_fetch_add))


@register
class _typing_long_atomic_fetch_add(ConcreteTemplate):
    key = globals()["long_atomic_fetch_add"]
    cases = [signature(int64, CPointer(int64), int64, int32)]

register_global(long_atomic_fetch_add, types.Function(_typing_long_atomic_fetch_add))


@register
class _typing_uint_atomic_fetch_add(ConcreteTemplate):
    key = globals()["uint_atomic_fetch_add"]
    cases = [signature(uint32, CPointer(uint32), uint32, int32)]

register_global(uint_atomic_fetch_add, types.Function(_typing_uint_atomic_fetch_add))


@register
class _typing_ulong_atomic_fetch_add(ConcreteTemplate):
    key = globals()["ulong_atomic_fetch_add"]
    cases = [signature(uint64, CPointer(uint64), uint64, int32)]

register_global(ulong_atomic_fetch_add, types.Function(_typing_ulong_atomic_fetch_add))


@register
class _typing_ulonglong_atomic_fetch_add(ConcreteTemplate):
    key = globals()["ulonglong_atomic_fetch_add"]
    cases = [signature(uint64, CPointer(uint64), uint64, int32)]

register_global(ulonglong_atomic_fetch_add, types.Function(_typing_ulonglong_atomic_fetch_add))


@register
class _typing_int32_atomic_fetch_add(ConcreteTemplate):
    key = globals()["int32_atomic_fetch_add"]
    cases = [signature(int32, CPointer(int32), int32, int32)]

register_global(int32_atomic_fetch_add, types.Function(_typing_int32_atomic_fetch_add))


@register
class _typing_uint32_atomic_fetch_add(ConcreteTemplate):
    key = globals()["uint32_atomic_fetch_add"]
    cases = [signature(uint32, CPointer(uint32), uint32, int32)]

register_global(uint32_atomic_fetch_add, types.Function(_typing_uint32_atomic_fetch_add))


@register
class _typing_uint64_atomic_fetch_add(ConcreteTemplate):
    key = globals()["uint64_atomic_fetch_add"]
    cases = [signature(uint64, CPointer(uint64), uint64, int32)]

register_global(uint64_atomic_fetch_add, types.Function(_typing_uint64_atomic_fetch_add))


@register
class _typing_size_atomic_fetch_add(ConcreteTemplate):
    key = globals()["size_atomic_fetch_add"]
    cases = [signature(uint64, CPointer(uint64), uint64, int32)]

register_global(size_atomic_fetch_add, types.Function(_typing_size_atomic_fetch_add))


@register
class _typing_int_atomic_add(ConcreteTemplate):
    key = globals()["int_atomic_add"]
    cases = [signature(void, CPointer(int32), int32, int32)]

register_global(int_atomic_add, types.Function(_typing_int_atomic_add))


@register
class _typing_long_atomic_add(ConcreteTemplate):
    key = globals()["long_atomic_add"]
    cases = [signature(void, CPointer(int64), int64, int32)]

register_global(long_atomic_add, types.Function(_typing_long_atomic_add))


@register
class _typing_uint_atomic_add(ConcreteTemplate):
    key = globals()["uint_atomic_add"]
    cases = [signature(void, CPointer(uint32), uint32, int32)]

register_global(uint_atomic_add, types.Function(_typing_uint_atomic_add))


@register
class _typing_ulong_atomic_add(ConcreteTemplate):
    key = globals()["ulong_atomic_add"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(ulong_atomic_add, types.Function(_typing_ulong_atomic_add))


@register
class _typing_ulonglong_atomic_add(ConcreteTemplate):
    key = globals()["ulonglong_atomic_add"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(ulonglong_atomic_add, types.Function(_typing_ulonglong_atomic_add))


@register
class _typing_int32_atomic_add(ConcreteTemplate):
    key = globals()["int32_atomic_add"]
    cases = [signature(void, CPointer(int32), int32, int32)]

register_global(int32_atomic_add, types.Function(_typing_int32_atomic_add))


@register
class _typing_uint32_atomic_add(ConcreteTemplate):
    key = globals()["uint32_atomic_add"]
    cases = [signature(void, CPointer(uint32), uint32, int32)]

register_global(uint32_atomic_add, types.Function(_typing_uint32_atomic_add))


@register
class _typing_uint64_atomic_add(ConcreteTemplate):
    key = globals()["uint64_atomic_add"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(uint64_atomic_add, types.Function(_typing_uint64_atomic_add))


@register
class _typing_size_atomic_add(ConcreteTemplate):
    key = globals()["size_atomic_add"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(size_atomic_add, types.Function(_typing_size_atomic_add))


@register
class _typing_int_atomic_fetch_inc(ConcreteTemplate):
    key = globals()["int_atomic_fetch_inc"]
    cases = [signature(int32, CPointer(int32), int32)]

register_global(int_atomic_fetch_inc, types.Function(_typing_int_atomic_fetch_inc))


@register
class _typing_long_atomic_fetch_inc(ConcreteTemplate):
    key = globals()["long_atomic_fetch_inc"]
    cases = [signature(int64, CPointer(int64), int32)]

register_global(long_atomic_fetch_inc, types.Function(_typing_long_atomic_fetch_inc))


@register
class _typing_uint_atomic_fetch_inc(ConcreteTemplate):
    key = globals()["uint_atomic_fetch_inc"]
    cases = [signature(uint32, CPointer(uint32), int32)]

register_global(uint_atomic_fetch_inc, types.Function(_typing_uint_atomic_fetch_inc))


@register
class _typing_ulong_atomic_fetch_inc(ConcreteTemplate):
    key = globals()["ulong_atomic_fetch_inc"]
    cases = [signature(uint64, CPointer(uint64), int32)]

register_global(ulong_atomic_fetch_inc, types.Function(_typing_ulong_atomic_fetch_inc))


@register
class _typing_ulonglong_atomic_fetch_inc(ConcreteTemplate):
    key = globals()["ulonglong_atomic_fetch_inc"]
    cases = [signature(uint64, CPointer(uint64), int32)]

register_global(ulonglong_atomic_fetch_inc, types.Function(_typing_ulonglong_atomic_fetch_inc))


@register
class _typing_int32_atomic_fetch_inc(ConcreteTemplate):
    key = globals()["int32_atomic_fetch_inc"]
    cases = [signature(int32, CPointer(int32), int32)]

register_global(int32_atomic_fetch_inc, types.Function(_typing_int32_atomic_fetch_inc))


@register
class _typing_uint32_atomic_fetch_inc(ConcreteTemplate):
    key = globals()["uint32_atomic_fetch_inc"]
    cases = [signature(uint32, CPointer(uint32), int32)]

register_global(uint32_atomic_fetch_inc, types.Function(_typing_uint32_atomic_fetch_inc))


@register
class _typing_uint64_atomic_fetch_inc(ConcreteTemplate):
    key = globals()["uint64_atomic_fetch_inc"]
    cases = [signature(uint64, CPointer(uint64), int32)]

register_global(uint64_atomic_fetch_inc, types.Function(_typing_uint64_atomic_fetch_inc))


@register
class _typing_size_atomic_fetch_inc(ConcreteTemplate):
    key = globals()["size_atomic_fetch_inc"]
    cases = [signature(uint64, CPointer(uint64), int32)]

register_global(size_atomic_fetch_inc, types.Function(_typing_size_atomic_fetch_inc))


@register
class _typing_int_atomic_inc(ConcreteTemplate):
    key = globals()["int_atomic_inc"]
    cases = [signature(void, CPointer(int32), int32)]

register_global(int_atomic_inc, types.Function(_typing_int_atomic_inc))


@register
class _typing_long_atomic_inc(ConcreteTemplate):
    key = globals()["long_atomic_inc"]
    cases = [signature(void, CPointer(int64), int32)]

register_global(long_atomic_inc, types.Function(_typing_long_atomic_inc))


@register
class _typing_uint_atomic_inc(ConcreteTemplate):
    key = globals()["uint_atomic_inc"]
    cases = [signature(void, CPointer(uint32), int32)]

register_global(uint_atomic_inc, types.Function(_typing_uint_atomic_inc))


@register
class _typing_ulong_atomic_inc(ConcreteTemplate):
    key = globals()["ulong_atomic_inc"]
    cases = [signature(void, CPointer(uint64), int32)]

register_global(ulong_atomic_inc, types.Function(_typing_ulong_atomic_inc))


@register
class _typing_ulonglong_atomic_inc(ConcreteTemplate):
    key = globals()["ulonglong_atomic_inc"]
    cases = [signature(void, CPointer(uint64), int32)]

register_global(ulonglong_atomic_inc, types.Function(_typing_ulonglong_atomic_inc))


@register
class _typing_int32_atomic_inc(ConcreteTemplate):
    key = globals()["int32_atomic_inc"]
    cases = [signature(void, CPointer(int32), int32)]

register_global(int32_atomic_inc, types.Function(_typing_int32_atomic_inc))


@register
class _typing_uint32_atomic_inc(ConcreteTemplate):
    key = globals()["uint32_atomic_inc"]
    cases = [signature(void, CPointer(uint32), int32)]

register_global(uint32_atomic_inc, types.Function(_typing_uint32_atomic_inc))


@register
class _typing_uint64_atomic_inc(ConcreteTemplate):
    key = globals()["uint64_atomic_inc"]
    cases = [signature(void, CPointer(uint64), int32)]

register_global(uint64_atomic_inc, types.Function(_typing_uint64_atomic_inc))


@register
class _typing_size_atomic_inc(ConcreteTemplate):
    key = globals()["size_atomic_inc"]
    cases = [signature(void, CPointer(uint64), int32)]

register_global(size_atomic_inc, types.Function(_typing_size_atomic_inc))


@register
class _typing_int_atomic_compare_swap(ConcreteTemplate):
    key = globals()["int_atomic_compare_swap"]
    cases = [signature(int32, CPointer(int32), int32, int32, int32)]

register_global(int_atomic_compare_swap, types.Function(_typing_int_atomic_compare_swap))


@register
class _typing_long_atomic_compare_swap(ConcreteTemplate):
    key = globals()["long_atomic_compare_swap"]
    cases = [signature(int64, CPointer(int64), int64, int64, int32)]

register_global(long_atomic_compare_swap, types.Function(_typing_long_atomic_compare_swap))


@register
class _typing_longlong_atomic_compare_swap(ConcreteTemplate):
    key = globals()["longlong_atomic_compare_swap"]
    cases = [signature(int64, CPointer(int64), int64, int64, int32)]

register_global(longlong_atomic_compare_swap, types.Function(_typing_longlong_atomic_compare_swap))


@register
class _typing_uint_atomic_compare_swap(ConcreteTemplate):
    key = globals()["uint_atomic_compare_swap"]
    cases = [signature(uint32, CPointer(uint32), uint32, uint32, int32)]

register_global(uint_atomic_compare_swap, types.Function(_typing_uint_atomic_compare_swap))


@register
class _typing_ulong_atomic_compare_swap(ConcreteTemplate):
    key = globals()["ulong_atomic_compare_swap"]
    cases = [signature(uint64, CPointer(uint64), uint64, uint64, int32)]

register_global(ulong_atomic_compare_swap, types.Function(_typing_ulong_atomic_compare_swap))


@register
class _typing_ulonglong_atomic_compare_swap(ConcreteTemplate):
    key = globals()["ulonglong_atomic_compare_swap"]
    cases = [signature(uint64, CPointer(uint64), uint64, uint64, int32)]

register_global(ulonglong_atomic_compare_swap, types.Function(_typing_ulonglong_atomic_compare_swap))


@register
class _typing_int32_atomic_compare_swap(ConcreteTemplate):
    key = globals()["int32_atomic_compare_swap"]
    cases = [signature(int32, CPointer(int32), int32, int32, int32)]

register_global(int32_atomic_compare_swap, types.Function(_typing_int32_atomic_compare_swap))


@register
class _typing_int64_atomic_compare_swap(ConcreteTemplate):
    key = globals()["int64_atomic_compare_swap"]
    cases = [signature(int64, CPointer(int64), int64, int64, int32)]

register_global(int64_atomic_compare_swap, types.Function(_typing_int64_atomic_compare_swap))


@register
class _typing_uint32_atomic_compare_swap(ConcreteTemplate):
    key = globals()["uint32_atomic_compare_swap"]
    cases = [signature(uint32, CPointer(uint32), uint32, uint32, int32)]

register_global(uint32_atomic_compare_swap, types.Function(_typing_uint32_atomic_compare_swap))


@register
class _typing_uint64_atomic_compare_swap(ConcreteTemplate):
    key = globals()["uint64_atomic_compare_swap"]
    cases = [signature(uint64, CPointer(uint64), uint64, uint64, int32)]

register_global(uint64_atomic_compare_swap, types.Function(_typing_uint64_atomic_compare_swap))


@register
class _typing_size_atomic_compare_swap(ConcreteTemplate):
    key = globals()["size_atomic_compare_swap"]
    cases = [signature(uint64, CPointer(uint64), uint64, uint64, int32)]

register_global(size_atomic_compare_swap, types.Function(_typing_size_atomic_compare_swap))


@register
class _typing_ptrdiff_atomic_compare_swap(ConcreteTemplate):
    key = globals()["ptrdiff_atomic_compare_swap"]
    cases = [signature(int64, CPointer(int64), int64, int64, int32)]

register_global(ptrdiff_atomic_compare_swap, types.Function(_typing_ptrdiff_atomic_compare_swap))


@register
class _typing_uint_atomic_fetch_and(ConcreteTemplate):
    key = globals()["uint_atomic_fetch_and"]
    cases = [signature(uint32, CPointer(uint32), uint32, int32)]

register_global(uint_atomic_fetch_and, types.Function(_typing_uint_atomic_fetch_and))


@register
class _typing_ulong_atomic_fetch_and(ConcreteTemplate):
    key = globals()["ulong_atomic_fetch_and"]
    cases = [signature(uint64, CPointer(uint64), uint64, int32)]

register_global(ulong_atomic_fetch_and, types.Function(_typing_ulong_atomic_fetch_and))


@register
class _typing_ulonglong_atomic_fetch_and(ConcreteTemplate):
    key = globals()["ulonglong_atomic_fetch_and"]
    cases = [signature(uint64, CPointer(uint64), uint64, int32)]

register_global(ulonglong_atomic_fetch_and, types.Function(_typing_ulonglong_atomic_fetch_and))


@register
class _typing_int32_atomic_fetch_and(ConcreteTemplate):
    key = globals()["int32_atomic_fetch_and"]
    cases = [signature(int32, CPointer(int32), int32, int32)]

register_global(int32_atomic_fetch_and, types.Function(_typing_int32_atomic_fetch_and))


@register
class _typing_int64_atomic_fetch_and(ConcreteTemplate):
    key = globals()["int64_atomic_fetch_and"]
    cases = [signature(int64, CPointer(int64), int64, int32)]

register_global(int64_atomic_fetch_and, types.Function(_typing_int64_atomic_fetch_and))


@register
class _typing_uint32_atomic_fetch_and(ConcreteTemplate):
    key = globals()["uint32_atomic_fetch_and"]
    cases = [signature(uint32, CPointer(uint32), uint32, int32)]

register_global(uint32_atomic_fetch_and, types.Function(_typing_uint32_atomic_fetch_and))


@register
class _typing_uint64_atomic_fetch_and(ConcreteTemplate):
    key = globals()["uint64_atomic_fetch_and"]
    cases = [signature(uint64, CPointer(uint64), uint64, int32)]

register_global(uint64_atomic_fetch_and, types.Function(_typing_uint64_atomic_fetch_and))


@register
class _typing_uint_atomic_and(ConcreteTemplate):
    key = globals()["uint_atomic_and"]
    cases = [signature(void, CPointer(uint32), uint32, int32)]

register_global(uint_atomic_and, types.Function(_typing_uint_atomic_and))


@register
class _typing_ulong_atomic_and(ConcreteTemplate):
    key = globals()["ulong_atomic_and"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(ulong_atomic_and, types.Function(_typing_ulong_atomic_and))


@register
class _typing_ulonglong_atomic_and(ConcreteTemplate):
    key = globals()["ulonglong_atomic_and"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(ulonglong_atomic_and, types.Function(_typing_ulonglong_atomic_and))


@register
class _typing_int32_atomic_and(ConcreteTemplate):
    key = globals()["int32_atomic_and"]
    cases = [signature(void, CPointer(int32), int32, int32)]

register_global(int32_atomic_and, types.Function(_typing_int32_atomic_and))


@register
class _typing_int64_atomic_and(ConcreteTemplate):
    key = globals()["int64_atomic_and"]
    cases = [signature(void, CPointer(int64), int64, int32)]

register_global(int64_atomic_and, types.Function(_typing_int64_atomic_and))


@register
class _typing_uint32_atomic_and(ConcreteTemplate):
    key = globals()["uint32_atomic_and"]
    cases = [signature(void, CPointer(uint32), uint32, int32)]

register_global(uint32_atomic_and, types.Function(_typing_uint32_atomic_and))


@register
class _typing_uint64_atomic_and(ConcreteTemplate):
    key = globals()["uint64_atomic_and"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(uint64_atomic_and, types.Function(_typing_uint64_atomic_and))


@register
class _typing_uint_atomic_fetch_or(ConcreteTemplate):
    key = globals()["uint_atomic_fetch_or"]
    cases = [signature(uint32, CPointer(uint32), uint32, int32)]

register_global(uint_atomic_fetch_or, types.Function(_typing_uint_atomic_fetch_or))


@register
class _typing_ulong_atomic_fetch_or(ConcreteTemplate):
    key = globals()["ulong_atomic_fetch_or"]
    cases = [signature(uint64, CPointer(uint64), uint64, int32)]

register_global(ulong_atomic_fetch_or, types.Function(_typing_ulong_atomic_fetch_or))


@register
class _typing_ulonglong_atomic_fetch_or(ConcreteTemplate):
    key = globals()["ulonglong_atomic_fetch_or"]
    cases = [signature(uint64, CPointer(uint64), uint64, int32)]

register_global(ulonglong_atomic_fetch_or, types.Function(_typing_ulonglong_atomic_fetch_or))


@register
class _typing_int32_atomic_fetch_or(ConcreteTemplate):
    key = globals()["int32_atomic_fetch_or"]
    cases = [signature(int32, CPointer(int32), int32, int32)]

register_global(int32_atomic_fetch_or, types.Function(_typing_int32_atomic_fetch_or))


@register
class _typing_int64_atomic_fetch_or(ConcreteTemplate):
    key = globals()["int64_atomic_fetch_or"]
    cases = [signature(int64, CPointer(int64), int64, int32)]

register_global(int64_atomic_fetch_or, types.Function(_typing_int64_atomic_fetch_or))


@register
class _typing_uint32_atomic_fetch_or(ConcreteTemplate):
    key = globals()["uint32_atomic_fetch_or"]
    cases = [signature(uint32, CPointer(uint32), uint32, int32)]

register_global(uint32_atomic_fetch_or, types.Function(_typing_uint32_atomic_fetch_or))


@register
class _typing_uint64_atomic_fetch_or(ConcreteTemplate):
    key = globals()["uint64_atomic_fetch_or"]
    cases = [signature(uint64, CPointer(uint64), uint64, int32)]

register_global(uint64_atomic_fetch_or, types.Function(_typing_uint64_atomic_fetch_or))


@register
class _typing_uint_atomic_or(ConcreteTemplate):
    key = globals()["uint_atomic_or"]
    cases = [signature(void, CPointer(uint32), uint32, int32)]

register_global(uint_atomic_or, types.Function(_typing_uint_atomic_or))


@register
class _typing_ulong_atomic_or(ConcreteTemplate):
    key = globals()["ulong_atomic_or"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(ulong_atomic_or, types.Function(_typing_ulong_atomic_or))


@register
class _typing_ulonglong_atomic_or(ConcreteTemplate):
    key = globals()["ulonglong_atomic_or"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(ulonglong_atomic_or, types.Function(_typing_ulonglong_atomic_or))


@register
class _typing_int32_atomic_or(ConcreteTemplate):
    key = globals()["int32_atomic_or"]
    cases = [signature(void, CPointer(int32), int32, int32)]

register_global(int32_atomic_or, types.Function(_typing_int32_atomic_or))


@register
class _typing_int64_atomic_or(ConcreteTemplate):
    key = globals()["int64_atomic_or"]
    cases = [signature(void, CPointer(int64), int64, int32)]

register_global(int64_atomic_or, types.Function(_typing_int64_atomic_or))


@register
class _typing_uint32_atomic_or(ConcreteTemplate):
    key = globals()["uint32_atomic_or"]
    cases = [signature(void, CPointer(uint32), uint32, int32)]

register_global(uint32_atomic_or, types.Function(_typing_uint32_atomic_or))


@register
class _typing_uint64_atomic_or(ConcreteTemplate):
    key = globals()["uint64_atomic_or"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(uint64_atomic_or, types.Function(_typing_uint64_atomic_or))


@register
class _typing_uint_atomic_fetch_xor(ConcreteTemplate):
    key = globals()["uint_atomic_fetch_xor"]
    cases = [signature(uint32, CPointer(uint32), uint32, int32)]

register_global(uint_atomic_fetch_xor, types.Function(_typing_uint_atomic_fetch_xor))


@register
class _typing_ulong_atomic_fetch_xor(ConcreteTemplate):
    key = globals()["ulong_atomic_fetch_xor"]
    cases = [signature(uint64, CPointer(uint64), uint64, int32)]

register_global(ulong_atomic_fetch_xor, types.Function(_typing_ulong_atomic_fetch_xor))


@register
class _typing_ulonglong_atomic_fetch_xor(ConcreteTemplate):
    key = globals()["ulonglong_atomic_fetch_xor"]
    cases = [signature(uint64, CPointer(uint64), uint64, int32)]

register_global(ulonglong_atomic_fetch_xor, types.Function(_typing_ulonglong_atomic_fetch_xor))


@register
class _typing_int32_atomic_fetch_xor(ConcreteTemplate):
    key = globals()["int32_atomic_fetch_xor"]
    cases = [signature(int32, CPointer(int32), int32, int32)]

register_global(int32_atomic_fetch_xor, types.Function(_typing_int32_atomic_fetch_xor))


@register
class _typing_int64_atomic_fetch_xor(ConcreteTemplate):
    key = globals()["int64_atomic_fetch_xor"]
    cases = [signature(int64, CPointer(int64), int64, int32)]

register_global(int64_atomic_fetch_xor, types.Function(_typing_int64_atomic_fetch_xor))


@register
class _typing_uint32_atomic_fetch_xor(ConcreteTemplate):
    key = globals()["uint32_atomic_fetch_xor"]
    cases = [signature(uint32, CPointer(uint32), uint32, int32)]

register_global(uint32_atomic_fetch_xor, types.Function(_typing_uint32_atomic_fetch_xor))


@register
class _typing_uint64_atomic_fetch_xor(ConcreteTemplate):
    key = globals()["uint64_atomic_fetch_xor"]
    cases = [signature(uint64, CPointer(uint64), uint64, int32)]

register_global(uint64_atomic_fetch_xor, types.Function(_typing_uint64_atomic_fetch_xor))


@register
class _typing_uint_atomic_xor(ConcreteTemplate):
    key = globals()["uint_atomic_xor"]
    cases = [signature(void, CPointer(uint32), uint32, int32)]

register_global(uint_atomic_xor, types.Function(_typing_uint_atomic_xor))


@register
class _typing_ulong_atomic_xor(ConcreteTemplate):
    key = globals()["ulong_atomic_xor"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(ulong_atomic_xor, types.Function(_typing_ulong_atomic_xor))


@register
class _typing_ulonglong_atomic_xor(ConcreteTemplate):
    key = globals()["ulonglong_atomic_xor"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(ulonglong_atomic_xor, types.Function(_typing_ulonglong_atomic_xor))


@register
class _typing_int32_atomic_xor(ConcreteTemplate):
    key = globals()["int32_atomic_xor"]
    cases = [signature(void, CPointer(int32), int32, int32)]

register_global(int32_atomic_xor, types.Function(_typing_int32_atomic_xor))


@register
class _typing_int64_atomic_xor(ConcreteTemplate):
    key = globals()["int64_atomic_xor"]
    cases = [signature(void, CPointer(int64), int64, int32)]

register_global(int64_atomic_xor, types.Function(_typing_int64_atomic_xor))


@register
class _typing_uint32_atomic_xor(ConcreteTemplate):
    key = globals()["uint32_atomic_xor"]
    cases = [signature(void, CPointer(uint32), uint32, int32)]

register_global(uint32_atomic_xor, types.Function(_typing_uint32_atomic_xor))


@register
class _typing_uint64_atomic_xor(ConcreteTemplate):
    key = globals()["uint64_atomic_xor"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(uint64_atomic_xor, types.Function(_typing_uint64_atomic_xor))


@register
class _typing_int_atomic_swap(ConcreteTemplate):
    key = globals()["int_atomic_swap"]
    cases = [signature(int32, CPointer(int32), int32, int32)]

register_global(int_atomic_swap, types.Function(_typing_int_atomic_swap))


@register
class _typing_long_atomic_swap(ConcreteTemplate):
    key = globals()["long_atomic_swap"]
    cases = [signature(int64, CPointer(int64), int64, int32)]

register_global(long_atomic_swap, types.Function(_typing_long_atomic_swap))


@register
class _typing_longlong_atomic_swap(ConcreteTemplate):
    key = globals()["longlong_atomic_swap"]
    cases = [signature(int64, CPointer(int64), int64, int32)]

register_global(longlong_atomic_swap, types.Function(_typing_longlong_atomic_swap))


@register
class _typing_uint_atomic_swap(ConcreteTemplate):
    key = globals()["uint_atomic_swap"]
    cases = [signature(uint32, CPointer(uint32), uint32, int32)]

register_global(uint_atomic_swap, types.Function(_typing_uint_atomic_swap))


@register
class _typing_ulong_atomic_swap(ConcreteTemplate):
    key = globals()["ulong_atomic_swap"]
    cases = [signature(uint64, CPointer(uint64), uint64, int32)]

register_global(ulong_atomic_swap, types.Function(_typing_ulong_atomic_swap))


@register
class _typing_ulonglong_atomic_swap(ConcreteTemplate):
    key = globals()["ulonglong_atomic_swap"]
    cases = [signature(uint64, CPointer(uint64), uint64, int32)]

register_global(ulonglong_atomic_swap, types.Function(_typing_ulonglong_atomic_swap))


@register
class _typing_int32_atomic_swap(ConcreteTemplate):
    key = globals()["int32_atomic_swap"]
    cases = [signature(int32, CPointer(int32), int32, int32)]

register_global(int32_atomic_swap, types.Function(_typing_int32_atomic_swap))


@register
class _typing_int64_atomic_swap(ConcreteTemplate):
    key = globals()["int64_atomic_swap"]
    cases = [signature(int64, CPointer(int64), int64, int32)]

register_global(int64_atomic_swap, types.Function(_typing_int64_atomic_swap))


@register
class _typing_uint32_atomic_swap(ConcreteTemplate):
    key = globals()["uint32_atomic_swap"]
    cases = [signature(uint32, CPointer(uint32), uint32, int32)]

register_global(uint32_atomic_swap, types.Function(_typing_uint32_atomic_swap))


@register
class _typing_uint64_atomic_swap(ConcreteTemplate):
    key = globals()["uint64_atomic_swap"]
    cases = [signature(uint64, CPointer(uint64), uint64, int32)]

register_global(uint64_atomic_swap, types.Function(_typing_uint64_atomic_swap))


@register
class _typing_float_atomic_swap(ConcreteTemplate):
    key = globals()["float_atomic_swap"]
    cases = [signature(float32, CPointer(float32), float32, int32)]

register_global(float_atomic_swap, types.Function(_typing_float_atomic_swap))


@register
class _typing_double_atomic_swap(ConcreteTemplate):
    key = globals()["double_atomic_swap"]
    cases = [signature(float64, CPointer(float64), float64, int32)]

register_global(double_atomic_swap, types.Function(_typing_double_atomic_swap))


@register
class _typing_size_atomic_swap(ConcreteTemplate):
    key = globals()["size_atomic_swap"]
    cases = [signature(uint64, CPointer(uint64), uint64, int32)]

register_global(size_atomic_swap, types.Function(_typing_size_atomic_swap))


@register
class _typing_ptrdiff_atomic_swap(ConcreteTemplate):
    key = globals()["ptrdiff_atomic_swap"]
    cases = [signature(int64, CPointer(int64), int64, int32)]

register_global(ptrdiff_atomic_swap, types.Function(_typing_ptrdiff_atomic_swap))


@register
class _typing_int_atomic_fetch(ConcreteTemplate):
    key = globals()["int_atomic_fetch"]
    cases = [signature(int32, CPointer(int32), int32)]

register_global(int_atomic_fetch, types.Function(_typing_int_atomic_fetch))


@register
class _typing_long_atomic_fetch(ConcreteTemplate):
    key = globals()["long_atomic_fetch"]
    cases = [signature(int64, CPointer(int64), int32)]

register_global(long_atomic_fetch, types.Function(_typing_long_atomic_fetch))


@register
class _typing_longlong_atomic_fetch(ConcreteTemplate):
    key = globals()["longlong_atomic_fetch"]
    cases = [signature(int64, CPointer(int64), int32)]

register_global(longlong_atomic_fetch, types.Function(_typing_longlong_atomic_fetch))


@register
class _typing_uint_atomic_fetch(ConcreteTemplate):
    key = globals()["uint_atomic_fetch"]
    cases = [signature(uint32, CPointer(uint32), int32)]

register_global(uint_atomic_fetch, types.Function(_typing_uint_atomic_fetch))


@register
class _typing_ulong_atomic_fetch(ConcreteTemplate):
    key = globals()["ulong_atomic_fetch"]
    cases = [signature(uint64, CPointer(uint64), int32)]

register_global(ulong_atomic_fetch, types.Function(_typing_ulong_atomic_fetch))


@register
class _typing_ulonglong_atomic_fetch(ConcreteTemplate):
    key = globals()["ulonglong_atomic_fetch"]
    cases = [signature(uint64, CPointer(uint64), int32)]

register_global(ulonglong_atomic_fetch, types.Function(_typing_ulonglong_atomic_fetch))


@register
class _typing_int32_atomic_fetch(ConcreteTemplate):
    key = globals()["int32_atomic_fetch"]
    cases = [signature(int32, CPointer(int32), int32)]

register_global(int32_atomic_fetch, types.Function(_typing_int32_atomic_fetch))


@register
class _typing_int64_atomic_fetch(ConcreteTemplate):
    key = globals()["int64_atomic_fetch"]
    cases = [signature(int64, CPointer(int64), int32)]

register_global(int64_atomic_fetch, types.Function(_typing_int64_atomic_fetch))


@register
class _typing_uint32_atomic_fetch(ConcreteTemplate):
    key = globals()["uint32_atomic_fetch"]
    cases = [signature(uint32, CPointer(uint32), int32)]

register_global(uint32_atomic_fetch, types.Function(_typing_uint32_atomic_fetch))


@register
class _typing_uint64_atomic_fetch(ConcreteTemplate):
    key = globals()["uint64_atomic_fetch"]
    cases = [signature(uint64, CPointer(uint64), int32)]

register_global(uint64_atomic_fetch, types.Function(_typing_uint64_atomic_fetch))


@register
class _typing_float_atomic_fetch(ConcreteTemplate):
    key = globals()["float_atomic_fetch"]
    cases = [signature(float32, CPointer(float32), int32)]

register_global(float_atomic_fetch, types.Function(_typing_float_atomic_fetch))


@register
class _typing_double_atomic_fetch(ConcreteTemplate):
    key = globals()["double_atomic_fetch"]
    cases = [signature(float64, CPointer(float64), int32)]

register_global(double_atomic_fetch, types.Function(_typing_double_atomic_fetch))


@register
class _typing_size_atomic_fetch(ConcreteTemplate):
    key = globals()["size_atomic_fetch"]
    cases = [signature(uint64, CPointer(uint64), int32)]

register_global(size_atomic_fetch, types.Function(_typing_size_atomic_fetch))


@register
class _typing_ptrdiff_atomic_fetch(ConcreteTemplate):
    key = globals()["ptrdiff_atomic_fetch"]
    cases = [signature(int64, CPointer(int64), int32)]

register_global(ptrdiff_atomic_fetch, types.Function(_typing_ptrdiff_atomic_fetch))


@register
class _typing_int_atomic_set(ConcreteTemplate):
    key = globals()["int_atomic_set"]
    cases = [signature(void, CPointer(int32), int32, int32)]

register_global(int_atomic_set, types.Function(_typing_int_atomic_set))


@register
class _typing_long_atomic_set(ConcreteTemplate):
    key = globals()["long_atomic_set"]
    cases = [signature(void, CPointer(int64), int64, int32)]

register_global(long_atomic_set, types.Function(_typing_long_atomic_set))


@register
class _typing_longlong_atomic_set(ConcreteTemplate):
    key = globals()["longlong_atomic_set"]
    cases = [signature(void, CPointer(int64), int64, int32)]

register_global(longlong_atomic_set, types.Function(_typing_longlong_atomic_set))


@register
class _typing_uint_atomic_set(ConcreteTemplate):
    key = globals()["uint_atomic_set"]
    cases = [signature(void, CPointer(uint32), uint32, int32)]

register_global(uint_atomic_set, types.Function(_typing_uint_atomic_set))


@register
class _typing_ulong_atomic_set(ConcreteTemplate):
    key = globals()["ulong_atomic_set"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(ulong_atomic_set, types.Function(_typing_ulong_atomic_set))


@register
class _typing_ulonglong_atomic_set(ConcreteTemplate):
    key = globals()["ulonglong_atomic_set"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(ulonglong_atomic_set, types.Function(_typing_ulonglong_atomic_set))


@register
class _typing_int32_atomic_set(ConcreteTemplate):
    key = globals()["int32_atomic_set"]
    cases = [signature(void, CPointer(int32), int32, int32)]

register_global(int32_atomic_set, types.Function(_typing_int32_atomic_set))


@register
class _typing_int64_atomic_set(ConcreteTemplate):
    key = globals()["int64_atomic_set"]
    cases = [signature(void, CPointer(int64), int64, int32)]

register_global(int64_atomic_set, types.Function(_typing_int64_atomic_set))


@register
class _typing_uint32_atomic_set(ConcreteTemplate):
    key = globals()["uint32_atomic_set"]
    cases = [signature(void, CPointer(uint32), uint32, int32)]

register_global(uint32_atomic_set, types.Function(_typing_uint32_atomic_set))


@register
class _typing_uint64_atomic_set(ConcreteTemplate):
    key = globals()["uint64_atomic_set"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(uint64_atomic_set, types.Function(_typing_uint64_atomic_set))


@register
class _typing_float_atomic_set(ConcreteTemplate):
    key = globals()["float_atomic_set"]
    cases = [signature(void, CPointer(float32), float32, int32)]

register_global(float_atomic_set, types.Function(_typing_float_atomic_set))


@register
class _typing_double_atomic_set(ConcreteTemplate):
    key = globals()["double_atomic_set"]
    cases = [signature(void, CPointer(float64), float64, int32)]

register_global(double_atomic_set, types.Function(_typing_double_atomic_set))


@register
class _typing_size_atomic_set(ConcreteTemplate):
    key = globals()["size_atomic_set"]
    cases = [signature(void, CPointer(uint64), uint64, int32)]

register_global(size_atomic_set, types.Function(_typing_size_atomic_set))


@register
class _typing_ptrdiff_atomic_set(ConcreteTemplate):
    key = globals()["ptrdiff_atomic_set"]
    cases = [signature(void, CPointer(int64), int64, int32)]

register_global(ptrdiff_atomic_set, types.Function(_typing_ptrdiff_atomic_set))


@register
class _typing_alltoallmem(ConcreteTemplate):
    key = globals()["alltoallmem"]
    cases = [signature(int32, int32, CPointer(void), CPointer(void), uint64)]

register_global(alltoallmem, types.Function(_typing_alltoallmem))


@register
class _typing_bfloat16_alltoall(ConcreteTemplate):
    key = globals()["bfloat16_alltoall"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_alltoall, types.Function(_typing_bfloat16_alltoall))


@register
class _typing_half_alltoall(ConcreteTemplate):
    key = globals()["half_alltoall"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_alltoall, types.Function(_typing_half_alltoall))


@register
class _typing_float_alltoall(ConcreteTemplate):
    key = globals()["float_alltoall"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_alltoall, types.Function(_typing_float_alltoall))


@register
class _typing_double_alltoall(ConcreteTemplate):
    key = globals()["double_alltoall"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_alltoall, types.Function(_typing_double_alltoall))


@register
class _typing_char_alltoall(ConcreteTemplate):
    key = globals()["char_alltoall"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_alltoall, types.Function(_typing_char_alltoall))


@register
class _typing_short_alltoall(ConcreteTemplate):
    key = globals()["short_alltoall"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_alltoall, types.Function(_typing_short_alltoall))


@register
class _typing_schar_alltoall(ConcreteTemplate):
    key = globals()["schar_alltoall"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_alltoall, types.Function(_typing_schar_alltoall))


@register
class _typing_int_alltoall(ConcreteTemplate):
    key = globals()["int_alltoall"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_alltoall, types.Function(_typing_int_alltoall))


@register
class _typing_long_alltoall(ConcreteTemplate):
    key = globals()["long_alltoall"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_alltoall, types.Function(_typing_long_alltoall))


@register
class _typing_longlong_alltoall(ConcreteTemplate):
    key = globals()["longlong_alltoall"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_alltoall, types.Function(_typing_longlong_alltoall))


@register
class _typing_uchar_alltoall(ConcreteTemplate):
    key = globals()["uchar_alltoall"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_alltoall, types.Function(_typing_uchar_alltoall))


@register
class _typing_ushort_alltoall(ConcreteTemplate):
    key = globals()["ushort_alltoall"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_alltoall, types.Function(_typing_ushort_alltoall))


@register
class _typing_uint_alltoall(ConcreteTemplate):
    key = globals()["uint_alltoall"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_alltoall, types.Function(_typing_uint_alltoall))


@register
class _typing_ulong_alltoall(ConcreteTemplate):
    key = globals()["ulong_alltoall"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_alltoall, types.Function(_typing_ulong_alltoall))


@register
class _typing_ulonglong_alltoall(ConcreteTemplate):
    key = globals()["ulonglong_alltoall"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_alltoall, types.Function(_typing_ulonglong_alltoall))


@register
class _typing_int8_alltoall(ConcreteTemplate):
    key = globals()["int8_alltoall"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_alltoall, types.Function(_typing_int8_alltoall))


@register
class _typing_int16_alltoall(ConcreteTemplate):
    key = globals()["int16_alltoall"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_alltoall, types.Function(_typing_int16_alltoall))


@register
class _typing_int32_alltoall(ConcreteTemplate):
    key = globals()["int32_alltoall"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_alltoall, types.Function(_typing_int32_alltoall))


@register
class _typing_int64_alltoall(ConcreteTemplate):
    key = globals()["int64_alltoall"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_alltoall, types.Function(_typing_int64_alltoall))


@register
class _typing_uint8_alltoall(ConcreteTemplate):
    key = globals()["uint8_alltoall"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_alltoall, types.Function(_typing_uint8_alltoall))


@register
class _typing_uint16_alltoall(ConcreteTemplate):
    key = globals()["uint16_alltoall"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_alltoall, types.Function(_typing_uint16_alltoall))


@register
class _typing_uint32_alltoall(ConcreteTemplate):
    key = globals()["uint32_alltoall"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_alltoall, types.Function(_typing_uint32_alltoall))


@register
class _typing_uint64_alltoall(ConcreteTemplate):
    key = globals()["uint64_alltoall"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_alltoall, types.Function(_typing_uint64_alltoall))


@register
class _typing_size_alltoall(ConcreteTemplate):
    key = globals()["size_alltoall"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_alltoall, types.Function(_typing_size_alltoall))


@register
class _typing_ptrdiff_alltoall(ConcreteTemplate):
    key = globals()["ptrdiff_alltoall"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(ptrdiff_alltoall, types.Function(_typing_ptrdiff_alltoall))


@register
class _typing_barrier(ConcreteTemplate):
    key = globals()["barrier"]
    cases = [signature(int32, int32)]

register_global(barrier, types.Function(_typing_barrier))


@register
class _typing_barrier_all(ConcreteTemplate):
    key = globals()["barrier_all"]
    cases = [signature(void, )]

register_global(barrier_all, types.Function(_typing_barrier_all))


@register
class _typing_team_sync(ConcreteTemplate):
    key = globals()["team_sync"]
    cases = [signature(int32, int32)]

register_global(team_sync, types.Function(_typing_team_sync))


@register
class _typing_sync_all(ConcreteTemplate):
    key = globals()["sync_all"]
    cases = [signature(void, )]

register_global(sync_all, types.Function(_typing_sync_all))


@register
class _typing_broadcastmem(ConcreteTemplate):
    key = globals()["broadcastmem"]
    cases = [signature(int32, int32, CPointer(void), CPointer(void), uint64, int32)]

register_global(broadcastmem, types.Function(_typing_broadcastmem))


@register
class _typing_bfloat16_broadcast(ConcreteTemplate):
    key = globals()["bfloat16_broadcast"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)]

register_global(bfloat16_broadcast, types.Function(_typing_bfloat16_broadcast))


@register
class _typing_half_broadcast(ConcreteTemplate):
    key = globals()["half_broadcast"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64, int32)]

register_global(half_broadcast, types.Function(_typing_half_broadcast))


@register
class _typing_float_broadcast(ConcreteTemplate):
    key = globals()["float_broadcast"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64, int32)]

register_global(float_broadcast, types.Function(_typing_float_broadcast))


@register
class _typing_double_broadcast(ConcreteTemplate):
    key = globals()["double_broadcast"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64, int32)]

register_global(double_broadcast, types.Function(_typing_double_broadcast))


@register
class _typing_char_broadcast(ConcreteTemplate):
    key = globals()["char_broadcast"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(char_broadcast, types.Function(_typing_char_broadcast))


@register
class _typing_short_broadcast(ConcreteTemplate):
    key = globals()["short_broadcast"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(short_broadcast, types.Function(_typing_short_broadcast))


@register
class _typing_schar_broadcast(ConcreteTemplate):
    key = globals()["schar_broadcast"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(schar_broadcast, types.Function(_typing_schar_broadcast))


@register
class _typing_int_broadcast(ConcreteTemplate):
    key = globals()["int_broadcast"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int_broadcast, types.Function(_typing_int_broadcast))


@register
class _typing_long_broadcast(ConcreteTemplate):
    key = globals()["long_broadcast"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(long_broadcast, types.Function(_typing_long_broadcast))


@register
class _typing_longlong_broadcast(ConcreteTemplate):
    key = globals()["longlong_broadcast"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(longlong_broadcast, types.Function(_typing_longlong_broadcast))


@register
class _typing_uchar_broadcast(ConcreteTemplate):
    key = globals()["uchar_broadcast"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uchar_broadcast, types.Function(_typing_uchar_broadcast))


@register
class _typing_ushort_broadcast(ConcreteTemplate):
    key = globals()["ushort_broadcast"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(ushort_broadcast, types.Function(_typing_ushort_broadcast))


@register
class _typing_uint_broadcast(ConcreteTemplate):
    key = globals()["uint_broadcast"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint_broadcast, types.Function(_typing_uint_broadcast))


@register
class _typing_ulong_broadcast(ConcreteTemplate):
    key = globals()["ulong_broadcast"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulong_broadcast, types.Function(_typing_ulong_broadcast))


@register
class _typing_ulonglong_broadcast(ConcreteTemplate):
    key = globals()["ulonglong_broadcast"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulonglong_broadcast, types.Function(_typing_ulonglong_broadcast))


@register
class _typing_int8_broadcast(ConcreteTemplate):
    key = globals()["int8_broadcast"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(int8_broadcast, types.Function(_typing_int8_broadcast))


@register
class _typing_int16_broadcast(ConcreteTemplate):
    key = globals()["int16_broadcast"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(int16_broadcast, types.Function(_typing_int16_broadcast))


@register
class _typing_int32_broadcast(ConcreteTemplate):
    key = globals()["int32_broadcast"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int32_broadcast, types.Function(_typing_int32_broadcast))


@register
class _typing_int64_broadcast(ConcreteTemplate):
    key = globals()["int64_broadcast"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(int64_broadcast, types.Function(_typing_int64_broadcast))


@register
class _typing_uint8_broadcast(ConcreteTemplate):
    key = globals()["uint8_broadcast"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uint8_broadcast, types.Function(_typing_uint8_broadcast))


@register
class _typing_uint16_broadcast(ConcreteTemplate):
    key = globals()["uint16_broadcast"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(uint16_broadcast, types.Function(_typing_uint16_broadcast))


@register
class _typing_uint32_broadcast(ConcreteTemplate):
    key = globals()["uint32_broadcast"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint32_broadcast, types.Function(_typing_uint32_broadcast))


@register
class _typing_uint64_broadcast(ConcreteTemplate):
    key = globals()["uint64_broadcast"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(uint64_broadcast, types.Function(_typing_uint64_broadcast))


@register
class _typing_size_broadcast(ConcreteTemplate):
    key = globals()["size_broadcast"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(size_broadcast, types.Function(_typing_size_broadcast))


@register
class _typing_ptrdiff_broadcast(ConcreteTemplate):
    key = globals()["ptrdiff_broadcast"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(ptrdiff_broadcast, types.Function(_typing_ptrdiff_broadcast))


@register
class _typing_fcollectmem(ConcreteTemplate):
    key = globals()["fcollectmem"]
    cases = [signature(int32, int32, CPointer(void), CPointer(void), uint64)]

register_global(fcollectmem, types.Function(_typing_fcollectmem))


@register
class _typing_bfloat16_fcollect(ConcreteTemplate):
    key = globals()["bfloat16_fcollect"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_fcollect, types.Function(_typing_bfloat16_fcollect))


@register
class _typing_half_fcollect(ConcreteTemplate):
    key = globals()["half_fcollect"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_fcollect, types.Function(_typing_half_fcollect))


@register
class _typing_float_fcollect(ConcreteTemplate):
    key = globals()["float_fcollect"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_fcollect, types.Function(_typing_float_fcollect))


@register
class _typing_double_fcollect(ConcreteTemplate):
    key = globals()["double_fcollect"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_fcollect, types.Function(_typing_double_fcollect))


@register
class _typing_char_fcollect(ConcreteTemplate):
    key = globals()["char_fcollect"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_fcollect, types.Function(_typing_char_fcollect))


@register
class _typing_short_fcollect(ConcreteTemplate):
    key = globals()["short_fcollect"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_fcollect, types.Function(_typing_short_fcollect))


@register
class _typing_schar_fcollect(ConcreteTemplate):
    key = globals()["schar_fcollect"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_fcollect, types.Function(_typing_schar_fcollect))


@register
class _typing_int_fcollect(ConcreteTemplate):
    key = globals()["int_fcollect"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_fcollect, types.Function(_typing_int_fcollect))


@register
class _typing_long_fcollect(ConcreteTemplate):
    key = globals()["long_fcollect"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_fcollect, types.Function(_typing_long_fcollect))


@register
class _typing_longlong_fcollect(ConcreteTemplate):
    key = globals()["longlong_fcollect"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_fcollect, types.Function(_typing_longlong_fcollect))


@register
class _typing_uchar_fcollect(ConcreteTemplate):
    key = globals()["uchar_fcollect"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_fcollect, types.Function(_typing_uchar_fcollect))


@register
class _typing_ushort_fcollect(ConcreteTemplate):
    key = globals()["ushort_fcollect"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_fcollect, types.Function(_typing_ushort_fcollect))


@register
class _typing_uint_fcollect(ConcreteTemplate):
    key = globals()["uint_fcollect"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_fcollect, types.Function(_typing_uint_fcollect))


@register
class _typing_ulong_fcollect(ConcreteTemplate):
    key = globals()["ulong_fcollect"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_fcollect, types.Function(_typing_ulong_fcollect))


@register
class _typing_ulonglong_fcollect(ConcreteTemplate):
    key = globals()["ulonglong_fcollect"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_fcollect, types.Function(_typing_ulonglong_fcollect))


@register
class _typing_int8_fcollect(ConcreteTemplate):
    key = globals()["int8_fcollect"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_fcollect, types.Function(_typing_int8_fcollect))


@register
class _typing_int16_fcollect(ConcreteTemplate):
    key = globals()["int16_fcollect"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_fcollect, types.Function(_typing_int16_fcollect))


@register
class _typing_int32_fcollect(ConcreteTemplate):
    key = globals()["int32_fcollect"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_fcollect, types.Function(_typing_int32_fcollect))


@register
class _typing_int64_fcollect(ConcreteTemplate):
    key = globals()["int64_fcollect"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_fcollect, types.Function(_typing_int64_fcollect))


@register
class _typing_uint8_fcollect(ConcreteTemplate):
    key = globals()["uint8_fcollect"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_fcollect, types.Function(_typing_uint8_fcollect))


@register
class _typing_uint16_fcollect(ConcreteTemplate):
    key = globals()["uint16_fcollect"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_fcollect, types.Function(_typing_uint16_fcollect))


@register
class _typing_uint32_fcollect(ConcreteTemplate):
    key = globals()["uint32_fcollect"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_fcollect, types.Function(_typing_uint32_fcollect))


@register
class _typing_uint64_fcollect(ConcreteTemplate):
    key = globals()["uint64_fcollect"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_fcollect, types.Function(_typing_uint64_fcollect))


@register
class _typing_size_fcollect(ConcreteTemplate):
    key = globals()["size_fcollect"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_fcollect, types.Function(_typing_size_fcollect))


@register
class _typing_ptrdiff_fcollect(ConcreteTemplate):
    key = globals()["ptrdiff_fcollect"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(ptrdiff_fcollect, types.Function(_typing_ptrdiff_fcollect))


@register
class _typing_uchar_and_reduce(ConcreteTemplate):
    key = globals()["uchar_and_reduce"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_and_reduce, types.Function(_typing_uchar_and_reduce))


@register
class _typing_ushort_and_reduce(ConcreteTemplate):
    key = globals()["ushort_and_reduce"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_and_reduce, types.Function(_typing_ushort_and_reduce))


@register
class _typing_uint_and_reduce(ConcreteTemplate):
    key = globals()["uint_and_reduce"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_and_reduce, types.Function(_typing_uint_and_reduce))


@register
class _typing_ulong_and_reduce(ConcreteTemplate):
    key = globals()["ulong_and_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_and_reduce, types.Function(_typing_ulong_and_reduce))


@register
class _typing_ulonglong_and_reduce(ConcreteTemplate):
    key = globals()["ulonglong_and_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_and_reduce, types.Function(_typing_ulonglong_and_reduce))


@register
class _typing_int8_and_reduce(ConcreteTemplate):
    key = globals()["int8_and_reduce"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_and_reduce, types.Function(_typing_int8_and_reduce))


@register
class _typing_int16_and_reduce(ConcreteTemplate):
    key = globals()["int16_and_reduce"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_and_reduce, types.Function(_typing_int16_and_reduce))


@register
class _typing_int32_and_reduce(ConcreteTemplate):
    key = globals()["int32_and_reduce"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_and_reduce, types.Function(_typing_int32_and_reduce))


@register
class _typing_int64_and_reduce(ConcreteTemplate):
    key = globals()["int64_and_reduce"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_and_reduce, types.Function(_typing_int64_and_reduce))


@register
class _typing_uint8_and_reduce(ConcreteTemplate):
    key = globals()["uint8_and_reduce"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_and_reduce, types.Function(_typing_uint8_and_reduce))


@register
class _typing_uint16_and_reduce(ConcreteTemplate):
    key = globals()["uint16_and_reduce"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_and_reduce, types.Function(_typing_uint16_and_reduce))


@register
class _typing_uint32_and_reduce(ConcreteTemplate):
    key = globals()["uint32_and_reduce"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_and_reduce, types.Function(_typing_uint32_and_reduce))


@register
class _typing_uint64_and_reduce(ConcreteTemplate):
    key = globals()["uint64_and_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_and_reduce, types.Function(_typing_uint64_and_reduce))


@register
class _typing_size_and_reduce(ConcreteTemplate):
    key = globals()["size_and_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_and_reduce, types.Function(_typing_size_and_reduce))


@register
class _typing_uchar_or_reduce(ConcreteTemplate):
    key = globals()["uchar_or_reduce"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_or_reduce, types.Function(_typing_uchar_or_reduce))


@register
class _typing_ushort_or_reduce(ConcreteTemplate):
    key = globals()["ushort_or_reduce"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_or_reduce, types.Function(_typing_ushort_or_reduce))


@register
class _typing_uint_or_reduce(ConcreteTemplate):
    key = globals()["uint_or_reduce"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_or_reduce, types.Function(_typing_uint_or_reduce))


@register
class _typing_ulong_or_reduce(ConcreteTemplate):
    key = globals()["ulong_or_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_or_reduce, types.Function(_typing_ulong_or_reduce))


@register
class _typing_ulonglong_or_reduce(ConcreteTemplate):
    key = globals()["ulonglong_or_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_or_reduce, types.Function(_typing_ulonglong_or_reduce))


@register
class _typing_int8_or_reduce(ConcreteTemplate):
    key = globals()["int8_or_reduce"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_or_reduce, types.Function(_typing_int8_or_reduce))


@register
class _typing_int16_or_reduce(ConcreteTemplate):
    key = globals()["int16_or_reduce"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_or_reduce, types.Function(_typing_int16_or_reduce))


@register
class _typing_int32_or_reduce(ConcreteTemplate):
    key = globals()["int32_or_reduce"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_or_reduce, types.Function(_typing_int32_or_reduce))


@register
class _typing_int64_or_reduce(ConcreteTemplate):
    key = globals()["int64_or_reduce"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_or_reduce, types.Function(_typing_int64_or_reduce))


@register
class _typing_uint8_or_reduce(ConcreteTemplate):
    key = globals()["uint8_or_reduce"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_or_reduce, types.Function(_typing_uint8_or_reduce))


@register
class _typing_uint16_or_reduce(ConcreteTemplate):
    key = globals()["uint16_or_reduce"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_or_reduce, types.Function(_typing_uint16_or_reduce))


@register
class _typing_uint32_or_reduce(ConcreteTemplate):
    key = globals()["uint32_or_reduce"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_or_reduce, types.Function(_typing_uint32_or_reduce))


@register
class _typing_uint64_or_reduce(ConcreteTemplate):
    key = globals()["uint64_or_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_or_reduce, types.Function(_typing_uint64_or_reduce))


@register
class _typing_size_or_reduce(ConcreteTemplate):
    key = globals()["size_or_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_or_reduce, types.Function(_typing_size_or_reduce))


@register
class _typing_uchar_xor_reduce(ConcreteTemplate):
    key = globals()["uchar_xor_reduce"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_xor_reduce, types.Function(_typing_uchar_xor_reduce))


@register
class _typing_ushort_xor_reduce(ConcreteTemplate):
    key = globals()["ushort_xor_reduce"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_xor_reduce, types.Function(_typing_ushort_xor_reduce))


@register
class _typing_uint_xor_reduce(ConcreteTemplate):
    key = globals()["uint_xor_reduce"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_xor_reduce, types.Function(_typing_uint_xor_reduce))


@register
class _typing_ulong_xor_reduce(ConcreteTemplate):
    key = globals()["ulong_xor_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_xor_reduce, types.Function(_typing_ulong_xor_reduce))


@register
class _typing_ulonglong_xor_reduce(ConcreteTemplate):
    key = globals()["ulonglong_xor_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_xor_reduce, types.Function(_typing_ulonglong_xor_reduce))


@register
class _typing_int8_xor_reduce(ConcreteTemplate):
    key = globals()["int8_xor_reduce"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_xor_reduce, types.Function(_typing_int8_xor_reduce))


@register
class _typing_int16_xor_reduce(ConcreteTemplate):
    key = globals()["int16_xor_reduce"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_xor_reduce, types.Function(_typing_int16_xor_reduce))


@register
class _typing_int32_xor_reduce(ConcreteTemplate):
    key = globals()["int32_xor_reduce"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_xor_reduce, types.Function(_typing_int32_xor_reduce))


@register
class _typing_int64_xor_reduce(ConcreteTemplate):
    key = globals()["int64_xor_reduce"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_xor_reduce, types.Function(_typing_int64_xor_reduce))


@register
class _typing_uint8_xor_reduce(ConcreteTemplate):
    key = globals()["uint8_xor_reduce"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_xor_reduce, types.Function(_typing_uint8_xor_reduce))


@register
class _typing_uint16_xor_reduce(ConcreteTemplate):
    key = globals()["uint16_xor_reduce"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_xor_reduce, types.Function(_typing_uint16_xor_reduce))


@register
class _typing_uint32_xor_reduce(ConcreteTemplate):
    key = globals()["uint32_xor_reduce"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_xor_reduce, types.Function(_typing_uint32_xor_reduce))


@register
class _typing_uint64_xor_reduce(ConcreteTemplate):
    key = globals()["uint64_xor_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_xor_reduce, types.Function(_typing_uint64_xor_reduce))


@register
class _typing_size_xor_reduce(ConcreteTemplate):
    key = globals()["size_xor_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_xor_reduce, types.Function(_typing_size_xor_reduce))


@register
class _typing_uchar_max_reduce(ConcreteTemplate):
    key = globals()["uchar_max_reduce"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_max_reduce, types.Function(_typing_uchar_max_reduce))


@register
class _typing_ushort_max_reduce(ConcreteTemplate):
    key = globals()["ushort_max_reduce"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_max_reduce, types.Function(_typing_ushort_max_reduce))


@register
class _typing_uint_max_reduce(ConcreteTemplate):
    key = globals()["uint_max_reduce"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_max_reduce, types.Function(_typing_uint_max_reduce))


@register
class _typing_ulong_max_reduce(ConcreteTemplate):
    key = globals()["ulong_max_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_max_reduce, types.Function(_typing_ulong_max_reduce))


@register
class _typing_ulonglong_max_reduce(ConcreteTemplate):
    key = globals()["ulonglong_max_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_max_reduce, types.Function(_typing_ulonglong_max_reduce))


@register
class _typing_int8_max_reduce(ConcreteTemplate):
    key = globals()["int8_max_reduce"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_max_reduce, types.Function(_typing_int8_max_reduce))


@register
class _typing_int16_max_reduce(ConcreteTemplate):
    key = globals()["int16_max_reduce"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_max_reduce, types.Function(_typing_int16_max_reduce))


@register
class _typing_int32_max_reduce(ConcreteTemplate):
    key = globals()["int32_max_reduce"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_max_reduce, types.Function(_typing_int32_max_reduce))


@register
class _typing_int64_max_reduce(ConcreteTemplate):
    key = globals()["int64_max_reduce"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_max_reduce, types.Function(_typing_int64_max_reduce))


@register
class _typing_uint8_max_reduce(ConcreteTemplate):
    key = globals()["uint8_max_reduce"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_max_reduce, types.Function(_typing_uint8_max_reduce))


@register
class _typing_uint16_max_reduce(ConcreteTemplate):
    key = globals()["uint16_max_reduce"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_max_reduce, types.Function(_typing_uint16_max_reduce))


@register
class _typing_uint32_max_reduce(ConcreteTemplate):
    key = globals()["uint32_max_reduce"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_max_reduce, types.Function(_typing_uint32_max_reduce))


@register
class _typing_uint64_max_reduce(ConcreteTemplate):
    key = globals()["uint64_max_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_max_reduce, types.Function(_typing_uint64_max_reduce))


@register
class _typing_size_max_reduce(ConcreteTemplate):
    key = globals()["size_max_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_max_reduce, types.Function(_typing_size_max_reduce))


@register
class _typing_char_max_reduce(ConcreteTemplate):
    key = globals()["char_max_reduce"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_max_reduce, types.Function(_typing_char_max_reduce))


@register
class _typing_schar_max_reduce(ConcreteTemplate):
    key = globals()["schar_max_reduce"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_max_reduce, types.Function(_typing_schar_max_reduce))


@register
class _typing_short_max_reduce(ConcreteTemplate):
    key = globals()["short_max_reduce"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_max_reduce, types.Function(_typing_short_max_reduce))


@register
class _typing_int_max_reduce(ConcreteTemplate):
    key = globals()["int_max_reduce"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_max_reduce, types.Function(_typing_int_max_reduce))


@register
class _typing_long_max_reduce(ConcreteTemplate):
    key = globals()["long_max_reduce"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_max_reduce, types.Function(_typing_long_max_reduce))


@register
class _typing_longlong_max_reduce(ConcreteTemplate):
    key = globals()["longlong_max_reduce"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_max_reduce, types.Function(_typing_longlong_max_reduce))


@register
class _typing_bfloat16_max_reduce(ConcreteTemplate):
    key = globals()["bfloat16_max_reduce"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_max_reduce, types.Function(_typing_bfloat16_max_reduce))


@register
class _typing_half_max_reduce(ConcreteTemplate):
    key = globals()["half_max_reduce"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_max_reduce, types.Function(_typing_half_max_reduce))


@register
class _typing_float_max_reduce(ConcreteTemplate):
    key = globals()["float_max_reduce"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_max_reduce, types.Function(_typing_float_max_reduce))


@register
class _typing_double_max_reduce(ConcreteTemplate):
    key = globals()["double_max_reduce"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_max_reduce, types.Function(_typing_double_max_reduce))


@register
class _typing_uchar_min_reduce(ConcreteTemplate):
    key = globals()["uchar_min_reduce"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_min_reduce, types.Function(_typing_uchar_min_reduce))


@register
class _typing_ushort_min_reduce(ConcreteTemplate):
    key = globals()["ushort_min_reduce"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_min_reduce, types.Function(_typing_ushort_min_reduce))


@register
class _typing_uint_min_reduce(ConcreteTemplate):
    key = globals()["uint_min_reduce"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_min_reduce, types.Function(_typing_uint_min_reduce))


@register
class _typing_ulong_min_reduce(ConcreteTemplate):
    key = globals()["ulong_min_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_min_reduce, types.Function(_typing_ulong_min_reduce))


@register
class _typing_ulonglong_min_reduce(ConcreteTemplate):
    key = globals()["ulonglong_min_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_min_reduce, types.Function(_typing_ulonglong_min_reduce))


@register
class _typing_int8_min_reduce(ConcreteTemplate):
    key = globals()["int8_min_reduce"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_min_reduce, types.Function(_typing_int8_min_reduce))


@register
class _typing_int16_min_reduce(ConcreteTemplate):
    key = globals()["int16_min_reduce"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_min_reduce, types.Function(_typing_int16_min_reduce))


@register
class _typing_int32_min_reduce(ConcreteTemplate):
    key = globals()["int32_min_reduce"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_min_reduce, types.Function(_typing_int32_min_reduce))


@register
class _typing_int64_min_reduce(ConcreteTemplate):
    key = globals()["int64_min_reduce"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_min_reduce, types.Function(_typing_int64_min_reduce))


@register
class _typing_uint8_min_reduce(ConcreteTemplate):
    key = globals()["uint8_min_reduce"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_min_reduce, types.Function(_typing_uint8_min_reduce))


@register
class _typing_uint16_min_reduce(ConcreteTemplate):
    key = globals()["uint16_min_reduce"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_min_reduce, types.Function(_typing_uint16_min_reduce))


@register
class _typing_uint32_min_reduce(ConcreteTemplate):
    key = globals()["uint32_min_reduce"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_min_reduce, types.Function(_typing_uint32_min_reduce))


@register
class _typing_uint64_min_reduce(ConcreteTemplate):
    key = globals()["uint64_min_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_min_reduce, types.Function(_typing_uint64_min_reduce))


@register
class _typing_size_min_reduce(ConcreteTemplate):
    key = globals()["size_min_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_min_reduce, types.Function(_typing_size_min_reduce))


@register
class _typing_char_min_reduce(ConcreteTemplate):
    key = globals()["char_min_reduce"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_min_reduce, types.Function(_typing_char_min_reduce))


@register
class _typing_schar_min_reduce(ConcreteTemplate):
    key = globals()["schar_min_reduce"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_min_reduce, types.Function(_typing_schar_min_reduce))


@register
class _typing_short_min_reduce(ConcreteTemplate):
    key = globals()["short_min_reduce"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_min_reduce, types.Function(_typing_short_min_reduce))


@register
class _typing_int_min_reduce(ConcreteTemplate):
    key = globals()["int_min_reduce"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_min_reduce, types.Function(_typing_int_min_reduce))


@register
class _typing_long_min_reduce(ConcreteTemplate):
    key = globals()["long_min_reduce"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_min_reduce, types.Function(_typing_long_min_reduce))


@register
class _typing_longlong_min_reduce(ConcreteTemplate):
    key = globals()["longlong_min_reduce"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_min_reduce, types.Function(_typing_longlong_min_reduce))


@register
class _typing_bfloat16_min_reduce(ConcreteTemplate):
    key = globals()["bfloat16_min_reduce"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_min_reduce, types.Function(_typing_bfloat16_min_reduce))


@register
class _typing_half_min_reduce(ConcreteTemplate):
    key = globals()["half_min_reduce"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_min_reduce, types.Function(_typing_half_min_reduce))


@register
class _typing_float_min_reduce(ConcreteTemplate):
    key = globals()["float_min_reduce"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_min_reduce, types.Function(_typing_float_min_reduce))


@register
class _typing_double_min_reduce(ConcreteTemplate):
    key = globals()["double_min_reduce"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_min_reduce, types.Function(_typing_double_min_reduce))


@register
class _typing_uchar_sum_reduce(ConcreteTemplate):
    key = globals()["uchar_sum_reduce"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_sum_reduce, types.Function(_typing_uchar_sum_reduce))


@register
class _typing_ushort_sum_reduce(ConcreteTemplate):
    key = globals()["ushort_sum_reduce"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_sum_reduce, types.Function(_typing_ushort_sum_reduce))


@register
class _typing_uint_sum_reduce(ConcreteTemplate):
    key = globals()["uint_sum_reduce"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_sum_reduce, types.Function(_typing_uint_sum_reduce))


@register
class _typing_ulong_sum_reduce(ConcreteTemplate):
    key = globals()["ulong_sum_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_sum_reduce, types.Function(_typing_ulong_sum_reduce))


@register
class _typing_ulonglong_sum_reduce(ConcreteTemplate):
    key = globals()["ulonglong_sum_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_sum_reduce, types.Function(_typing_ulonglong_sum_reduce))


@register
class _typing_int8_sum_reduce(ConcreteTemplate):
    key = globals()["int8_sum_reduce"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_sum_reduce, types.Function(_typing_int8_sum_reduce))


@register
class _typing_int16_sum_reduce(ConcreteTemplate):
    key = globals()["int16_sum_reduce"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_sum_reduce, types.Function(_typing_int16_sum_reduce))


@register
class _typing_int32_sum_reduce(ConcreteTemplate):
    key = globals()["int32_sum_reduce"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_sum_reduce, types.Function(_typing_int32_sum_reduce))


@register
class _typing_int64_sum_reduce(ConcreteTemplate):
    key = globals()["int64_sum_reduce"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_sum_reduce, types.Function(_typing_int64_sum_reduce))


@register
class _typing_uint8_sum_reduce(ConcreteTemplate):
    key = globals()["uint8_sum_reduce"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_sum_reduce, types.Function(_typing_uint8_sum_reduce))


@register
class _typing_uint16_sum_reduce(ConcreteTemplate):
    key = globals()["uint16_sum_reduce"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_sum_reduce, types.Function(_typing_uint16_sum_reduce))


@register
class _typing_uint32_sum_reduce(ConcreteTemplate):
    key = globals()["uint32_sum_reduce"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_sum_reduce, types.Function(_typing_uint32_sum_reduce))


@register
class _typing_uint64_sum_reduce(ConcreteTemplate):
    key = globals()["uint64_sum_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_sum_reduce, types.Function(_typing_uint64_sum_reduce))


@register
class _typing_size_sum_reduce(ConcreteTemplate):
    key = globals()["size_sum_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_sum_reduce, types.Function(_typing_size_sum_reduce))


@register
class _typing_char_sum_reduce(ConcreteTemplate):
    key = globals()["char_sum_reduce"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_sum_reduce, types.Function(_typing_char_sum_reduce))


@register
class _typing_schar_sum_reduce(ConcreteTemplate):
    key = globals()["schar_sum_reduce"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_sum_reduce, types.Function(_typing_schar_sum_reduce))


@register
class _typing_short_sum_reduce(ConcreteTemplate):
    key = globals()["short_sum_reduce"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_sum_reduce, types.Function(_typing_short_sum_reduce))


@register
class _typing_int_sum_reduce(ConcreteTemplate):
    key = globals()["int_sum_reduce"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_sum_reduce, types.Function(_typing_int_sum_reduce))


@register
class _typing_long_sum_reduce(ConcreteTemplate):
    key = globals()["long_sum_reduce"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_sum_reduce, types.Function(_typing_long_sum_reduce))


@register
class _typing_longlong_sum_reduce(ConcreteTemplate):
    key = globals()["longlong_sum_reduce"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_sum_reduce, types.Function(_typing_longlong_sum_reduce))


@register
class _typing_bfloat16_sum_reduce(ConcreteTemplate):
    key = globals()["bfloat16_sum_reduce"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_sum_reduce, types.Function(_typing_bfloat16_sum_reduce))


@register
class _typing_half_sum_reduce(ConcreteTemplate):
    key = globals()["half_sum_reduce"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_sum_reduce, types.Function(_typing_half_sum_reduce))


@register
class _typing_float_sum_reduce(ConcreteTemplate):
    key = globals()["float_sum_reduce"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_sum_reduce, types.Function(_typing_float_sum_reduce))


@register
class _typing_double_sum_reduce(ConcreteTemplate):
    key = globals()["double_sum_reduce"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_sum_reduce, types.Function(_typing_double_sum_reduce))


@register
class _typing_uchar_prod_reduce(ConcreteTemplate):
    key = globals()["uchar_prod_reduce"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_prod_reduce, types.Function(_typing_uchar_prod_reduce))


@register
class _typing_ushort_prod_reduce(ConcreteTemplate):
    key = globals()["ushort_prod_reduce"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_prod_reduce, types.Function(_typing_ushort_prod_reduce))


@register
class _typing_uint_prod_reduce(ConcreteTemplate):
    key = globals()["uint_prod_reduce"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_prod_reduce, types.Function(_typing_uint_prod_reduce))


@register
class _typing_ulong_prod_reduce(ConcreteTemplate):
    key = globals()["ulong_prod_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_prod_reduce, types.Function(_typing_ulong_prod_reduce))


@register
class _typing_ulonglong_prod_reduce(ConcreteTemplate):
    key = globals()["ulonglong_prod_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_prod_reduce, types.Function(_typing_ulonglong_prod_reduce))


@register
class _typing_int8_prod_reduce(ConcreteTemplate):
    key = globals()["int8_prod_reduce"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_prod_reduce, types.Function(_typing_int8_prod_reduce))


@register
class _typing_int16_prod_reduce(ConcreteTemplate):
    key = globals()["int16_prod_reduce"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_prod_reduce, types.Function(_typing_int16_prod_reduce))


@register
class _typing_int32_prod_reduce(ConcreteTemplate):
    key = globals()["int32_prod_reduce"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_prod_reduce, types.Function(_typing_int32_prod_reduce))


@register
class _typing_int64_prod_reduce(ConcreteTemplate):
    key = globals()["int64_prod_reduce"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_prod_reduce, types.Function(_typing_int64_prod_reduce))


@register
class _typing_uint8_prod_reduce(ConcreteTemplate):
    key = globals()["uint8_prod_reduce"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_prod_reduce, types.Function(_typing_uint8_prod_reduce))


@register
class _typing_uint16_prod_reduce(ConcreteTemplate):
    key = globals()["uint16_prod_reduce"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_prod_reduce, types.Function(_typing_uint16_prod_reduce))


@register
class _typing_uint32_prod_reduce(ConcreteTemplate):
    key = globals()["uint32_prod_reduce"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_prod_reduce, types.Function(_typing_uint32_prod_reduce))


@register
class _typing_uint64_prod_reduce(ConcreteTemplate):
    key = globals()["uint64_prod_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_prod_reduce, types.Function(_typing_uint64_prod_reduce))


@register
class _typing_size_prod_reduce(ConcreteTemplate):
    key = globals()["size_prod_reduce"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_prod_reduce, types.Function(_typing_size_prod_reduce))


@register
class _typing_char_prod_reduce(ConcreteTemplate):
    key = globals()["char_prod_reduce"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_prod_reduce, types.Function(_typing_char_prod_reduce))


@register
class _typing_schar_prod_reduce(ConcreteTemplate):
    key = globals()["schar_prod_reduce"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_prod_reduce, types.Function(_typing_schar_prod_reduce))


@register
class _typing_short_prod_reduce(ConcreteTemplate):
    key = globals()["short_prod_reduce"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_prod_reduce, types.Function(_typing_short_prod_reduce))


@register
class _typing_int_prod_reduce(ConcreteTemplate):
    key = globals()["int_prod_reduce"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_prod_reduce, types.Function(_typing_int_prod_reduce))


@register
class _typing_long_prod_reduce(ConcreteTemplate):
    key = globals()["long_prod_reduce"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_prod_reduce, types.Function(_typing_long_prod_reduce))


@register
class _typing_longlong_prod_reduce(ConcreteTemplate):
    key = globals()["longlong_prod_reduce"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_prod_reduce, types.Function(_typing_longlong_prod_reduce))


@register
class _typing_bfloat16_prod_reduce(ConcreteTemplate):
    key = globals()["bfloat16_prod_reduce"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_prod_reduce, types.Function(_typing_bfloat16_prod_reduce))


@register
class _typing_half_prod_reduce(ConcreteTemplate):
    key = globals()["half_prod_reduce"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_prod_reduce, types.Function(_typing_half_prod_reduce))


@register
class _typing_float_prod_reduce(ConcreteTemplate):
    key = globals()["float_prod_reduce"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_prod_reduce, types.Function(_typing_float_prod_reduce))


@register
class _typing_double_prod_reduce(ConcreteTemplate):
    key = globals()["double_prod_reduce"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_prod_reduce, types.Function(_typing_double_prod_reduce))


@register
class _typing_uchar_and_reducescatter(ConcreteTemplate):
    key = globals()["uchar_and_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_and_reducescatter, types.Function(_typing_uchar_and_reducescatter))


@register
class _typing_ushort_and_reducescatter(ConcreteTemplate):
    key = globals()["ushort_and_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_and_reducescatter, types.Function(_typing_ushort_and_reducescatter))


@register
class _typing_uint_and_reducescatter(ConcreteTemplate):
    key = globals()["uint_and_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_and_reducescatter, types.Function(_typing_uint_and_reducescatter))


@register
class _typing_ulong_and_reducescatter(ConcreteTemplate):
    key = globals()["ulong_and_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_and_reducescatter, types.Function(_typing_ulong_and_reducescatter))


@register
class _typing_ulonglong_and_reducescatter(ConcreteTemplate):
    key = globals()["ulonglong_and_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_and_reducescatter, types.Function(_typing_ulonglong_and_reducescatter))


@register
class _typing_int8_and_reducescatter(ConcreteTemplate):
    key = globals()["int8_and_reducescatter"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_and_reducescatter, types.Function(_typing_int8_and_reducescatter))


@register
class _typing_int16_and_reducescatter(ConcreteTemplate):
    key = globals()["int16_and_reducescatter"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_and_reducescatter, types.Function(_typing_int16_and_reducescatter))


@register
class _typing_int32_and_reducescatter(ConcreteTemplate):
    key = globals()["int32_and_reducescatter"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_and_reducescatter, types.Function(_typing_int32_and_reducescatter))


@register
class _typing_int64_and_reducescatter(ConcreteTemplate):
    key = globals()["int64_and_reducescatter"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_and_reducescatter, types.Function(_typing_int64_and_reducescatter))


@register
class _typing_uint8_and_reducescatter(ConcreteTemplate):
    key = globals()["uint8_and_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_and_reducescatter, types.Function(_typing_uint8_and_reducescatter))


@register
class _typing_uint16_and_reducescatter(ConcreteTemplate):
    key = globals()["uint16_and_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_and_reducescatter, types.Function(_typing_uint16_and_reducescatter))


@register
class _typing_uint32_and_reducescatter(ConcreteTemplate):
    key = globals()["uint32_and_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_and_reducescatter, types.Function(_typing_uint32_and_reducescatter))


@register
class _typing_uint64_and_reducescatter(ConcreteTemplate):
    key = globals()["uint64_and_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_and_reducescatter, types.Function(_typing_uint64_and_reducescatter))


@register
class _typing_size_and_reducescatter(ConcreteTemplate):
    key = globals()["size_and_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_and_reducescatter, types.Function(_typing_size_and_reducescatter))


@register
class _typing_uchar_or_reducescatter(ConcreteTemplate):
    key = globals()["uchar_or_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_or_reducescatter, types.Function(_typing_uchar_or_reducescatter))


@register
class _typing_ushort_or_reducescatter(ConcreteTemplate):
    key = globals()["ushort_or_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_or_reducescatter, types.Function(_typing_ushort_or_reducescatter))


@register
class _typing_uint_or_reducescatter(ConcreteTemplate):
    key = globals()["uint_or_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_or_reducescatter, types.Function(_typing_uint_or_reducescatter))


@register
class _typing_ulong_or_reducescatter(ConcreteTemplate):
    key = globals()["ulong_or_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_or_reducescatter, types.Function(_typing_ulong_or_reducescatter))


@register
class _typing_ulonglong_or_reducescatter(ConcreteTemplate):
    key = globals()["ulonglong_or_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_or_reducescatter, types.Function(_typing_ulonglong_or_reducescatter))


@register
class _typing_int8_or_reducescatter(ConcreteTemplate):
    key = globals()["int8_or_reducescatter"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_or_reducescatter, types.Function(_typing_int8_or_reducescatter))


@register
class _typing_int16_or_reducescatter(ConcreteTemplate):
    key = globals()["int16_or_reducescatter"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_or_reducescatter, types.Function(_typing_int16_or_reducescatter))


@register
class _typing_int32_or_reducescatter(ConcreteTemplate):
    key = globals()["int32_or_reducescatter"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_or_reducescatter, types.Function(_typing_int32_or_reducescatter))


@register
class _typing_int64_or_reducescatter(ConcreteTemplate):
    key = globals()["int64_or_reducescatter"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_or_reducescatter, types.Function(_typing_int64_or_reducescatter))


@register
class _typing_uint8_or_reducescatter(ConcreteTemplate):
    key = globals()["uint8_or_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_or_reducescatter, types.Function(_typing_uint8_or_reducescatter))


@register
class _typing_uint16_or_reducescatter(ConcreteTemplate):
    key = globals()["uint16_or_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_or_reducescatter, types.Function(_typing_uint16_or_reducescatter))


@register
class _typing_uint32_or_reducescatter(ConcreteTemplate):
    key = globals()["uint32_or_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_or_reducescatter, types.Function(_typing_uint32_or_reducescatter))


@register
class _typing_uint64_or_reducescatter(ConcreteTemplate):
    key = globals()["uint64_or_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_or_reducescatter, types.Function(_typing_uint64_or_reducescatter))


@register
class _typing_size_or_reducescatter(ConcreteTemplate):
    key = globals()["size_or_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_or_reducescatter, types.Function(_typing_size_or_reducescatter))


@register
class _typing_uchar_xor_reducescatter(ConcreteTemplate):
    key = globals()["uchar_xor_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_xor_reducescatter, types.Function(_typing_uchar_xor_reducescatter))


@register
class _typing_ushort_xor_reducescatter(ConcreteTemplate):
    key = globals()["ushort_xor_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_xor_reducescatter, types.Function(_typing_ushort_xor_reducescatter))


@register
class _typing_uint_xor_reducescatter(ConcreteTemplate):
    key = globals()["uint_xor_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_xor_reducescatter, types.Function(_typing_uint_xor_reducescatter))


@register
class _typing_ulong_xor_reducescatter(ConcreteTemplate):
    key = globals()["ulong_xor_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_xor_reducescatter, types.Function(_typing_ulong_xor_reducescatter))


@register
class _typing_ulonglong_xor_reducescatter(ConcreteTemplate):
    key = globals()["ulonglong_xor_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_xor_reducescatter, types.Function(_typing_ulonglong_xor_reducescatter))


@register
class _typing_int8_xor_reducescatter(ConcreteTemplate):
    key = globals()["int8_xor_reducescatter"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_xor_reducescatter, types.Function(_typing_int8_xor_reducescatter))


@register
class _typing_int16_xor_reducescatter(ConcreteTemplate):
    key = globals()["int16_xor_reducescatter"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_xor_reducescatter, types.Function(_typing_int16_xor_reducescatter))


@register
class _typing_int32_xor_reducescatter(ConcreteTemplate):
    key = globals()["int32_xor_reducescatter"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_xor_reducescatter, types.Function(_typing_int32_xor_reducescatter))


@register
class _typing_int64_xor_reducescatter(ConcreteTemplate):
    key = globals()["int64_xor_reducescatter"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_xor_reducescatter, types.Function(_typing_int64_xor_reducescatter))


@register
class _typing_uint8_xor_reducescatter(ConcreteTemplate):
    key = globals()["uint8_xor_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_xor_reducescatter, types.Function(_typing_uint8_xor_reducescatter))


@register
class _typing_uint16_xor_reducescatter(ConcreteTemplate):
    key = globals()["uint16_xor_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_xor_reducescatter, types.Function(_typing_uint16_xor_reducescatter))


@register
class _typing_uint32_xor_reducescatter(ConcreteTemplate):
    key = globals()["uint32_xor_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_xor_reducescatter, types.Function(_typing_uint32_xor_reducescatter))


@register
class _typing_uint64_xor_reducescatter(ConcreteTemplate):
    key = globals()["uint64_xor_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_xor_reducescatter, types.Function(_typing_uint64_xor_reducescatter))


@register
class _typing_size_xor_reducescatter(ConcreteTemplate):
    key = globals()["size_xor_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_xor_reducescatter, types.Function(_typing_size_xor_reducescatter))


@register
class _typing_uchar_max_reducescatter(ConcreteTemplate):
    key = globals()["uchar_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_max_reducescatter, types.Function(_typing_uchar_max_reducescatter))


@register
class _typing_ushort_max_reducescatter(ConcreteTemplate):
    key = globals()["ushort_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_max_reducescatter, types.Function(_typing_ushort_max_reducescatter))


@register
class _typing_uint_max_reducescatter(ConcreteTemplate):
    key = globals()["uint_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_max_reducescatter, types.Function(_typing_uint_max_reducescatter))


@register
class _typing_ulong_max_reducescatter(ConcreteTemplate):
    key = globals()["ulong_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_max_reducescatter, types.Function(_typing_ulong_max_reducescatter))


@register
class _typing_ulonglong_max_reducescatter(ConcreteTemplate):
    key = globals()["ulonglong_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_max_reducescatter, types.Function(_typing_ulonglong_max_reducescatter))


@register
class _typing_int8_max_reducescatter(ConcreteTemplate):
    key = globals()["int8_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_max_reducescatter, types.Function(_typing_int8_max_reducescatter))


@register
class _typing_int16_max_reducescatter(ConcreteTemplate):
    key = globals()["int16_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_max_reducescatter, types.Function(_typing_int16_max_reducescatter))


@register
class _typing_int32_max_reducescatter(ConcreteTemplate):
    key = globals()["int32_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_max_reducescatter, types.Function(_typing_int32_max_reducescatter))


@register
class _typing_int64_max_reducescatter(ConcreteTemplate):
    key = globals()["int64_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_max_reducescatter, types.Function(_typing_int64_max_reducescatter))


@register
class _typing_uint8_max_reducescatter(ConcreteTemplate):
    key = globals()["uint8_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_max_reducescatter, types.Function(_typing_uint8_max_reducescatter))


@register
class _typing_uint16_max_reducescatter(ConcreteTemplate):
    key = globals()["uint16_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_max_reducescatter, types.Function(_typing_uint16_max_reducescatter))


@register
class _typing_uint32_max_reducescatter(ConcreteTemplate):
    key = globals()["uint32_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_max_reducescatter, types.Function(_typing_uint32_max_reducescatter))


@register
class _typing_uint64_max_reducescatter(ConcreteTemplate):
    key = globals()["uint64_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_max_reducescatter, types.Function(_typing_uint64_max_reducescatter))


@register
class _typing_size_max_reducescatter(ConcreteTemplate):
    key = globals()["size_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_max_reducescatter, types.Function(_typing_size_max_reducescatter))


@register
class _typing_char_max_reducescatter(ConcreteTemplate):
    key = globals()["char_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_max_reducescatter, types.Function(_typing_char_max_reducescatter))


@register
class _typing_schar_max_reducescatter(ConcreteTemplate):
    key = globals()["schar_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_max_reducescatter, types.Function(_typing_schar_max_reducescatter))


@register
class _typing_short_max_reducescatter(ConcreteTemplate):
    key = globals()["short_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_max_reducescatter, types.Function(_typing_short_max_reducescatter))


@register
class _typing_int_max_reducescatter(ConcreteTemplate):
    key = globals()["int_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_max_reducescatter, types.Function(_typing_int_max_reducescatter))


@register
class _typing_long_max_reducescatter(ConcreteTemplate):
    key = globals()["long_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_max_reducescatter, types.Function(_typing_long_max_reducescatter))


@register
class _typing_longlong_max_reducescatter(ConcreteTemplate):
    key = globals()["longlong_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_max_reducescatter, types.Function(_typing_longlong_max_reducescatter))


@register
class _typing_bfloat16_max_reducescatter(ConcreteTemplate):
    key = globals()["bfloat16_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_max_reducescatter, types.Function(_typing_bfloat16_max_reducescatter))


@register
class _typing_half_max_reducescatter(ConcreteTemplate):
    key = globals()["half_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_max_reducescatter, types.Function(_typing_half_max_reducescatter))


@register
class _typing_float_max_reducescatter(ConcreteTemplate):
    key = globals()["float_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_max_reducescatter, types.Function(_typing_float_max_reducescatter))


@register
class _typing_double_max_reducescatter(ConcreteTemplate):
    key = globals()["double_max_reducescatter"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_max_reducescatter, types.Function(_typing_double_max_reducescatter))


@register
class _typing_uchar_min_reducescatter(ConcreteTemplate):
    key = globals()["uchar_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_min_reducescatter, types.Function(_typing_uchar_min_reducescatter))


@register
class _typing_ushort_min_reducescatter(ConcreteTemplate):
    key = globals()["ushort_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_min_reducescatter, types.Function(_typing_ushort_min_reducescatter))


@register
class _typing_uint_min_reducescatter(ConcreteTemplate):
    key = globals()["uint_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_min_reducescatter, types.Function(_typing_uint_min_reducescatter))


@register
class _typing_ulong_min_reducescatter(ConcreteTemplate):
    key = globals()["ulong_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_min_reducescatter, types.Function(_typing_ulong_min_reducescatter))


@register
class _typing_ulonglong_min_reducescatter(ConcreteTemplate):
    key = globals()["ulonglong_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_min_reducescatter, types.Function(_typing_ulonglong_min_reducescatter))


@register
class _typing_int8_min_reducescatter(ConcreteTemplate):
    key = globals()["int8_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_min_reducescatter, types.Function(_typing_int8_min_reducescatter))


@register
class _typing_int16_min_reducescatter(ConcreteTemplate):
    key = globals()["int16_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_min_reducescatter, types.Function(_typing_int16_min_reducescatter))


@register
class _typing_int32_min_reducescatter(ConcreteTemplate):
    key = globals()["int32_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_min_reducescatter, types.Function(_typing_int32_min_reducescatter))


@register
class _typing_int64_min_reducescatter(ConcreteTemplate):
    key = globals()["int64_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_min_reducescatter, types.Function(_typing_int64_min_reducescatter))


@register
class _typing_uint8_min_reducescatter(ConcreteTemplate):
    key = globals()["uint8_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_min_reducescatter, types.Function(_typing_uint8_min_reducescatter))


@register
class _typing_uint16_min_reducescatter(ConcreteTemplate):
    key = globals()["uint16_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_min_reducescatter, types.Function(_typing_uint16_min_reducescatter))


@register
class _typing_uint32_min_reducescatter(ConcreteTemplate):
    key = globals()["uint32_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_min_reducescatter, types.Function(_typing_uint32_min_reducescatter))


@register
class _typing_uint64_min_reducescatter(ConcreteTemplate):
    key = globals()["uint64_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_min_reducescatter, types.Function(_typing_uint64_min_reducescatter))


@register
class _typing_size_min_reducescatter(ConcreteTemplate):
    key = globals()["size_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_min_reducescatter, types.Function(_typing_size_min_reducescatter))


@register
class _typing_char_min_reducescatter(ConcreteTemplate):
    key = globals()["char_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_min_reducescatter, types.Function(_typing_char_min_reducescatter))


@register
class _typing_schar_min_reducescatter(ConcreteTemplate):
    key = globals()["schar_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_min_reducescatter, types.Function(_typing_schar_min_reducescatter))


@register
class _typing_short_min_reducescatter(ConcreteTemplate):
    key = globals()["short_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_min_reducescatter, types.Function(_typing_short_min_reducescatter))


@register
class _typing_int_min_reducescatter(ConcreteTemplate):
    key = globals()["int_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_min_reducescatter, types.Function(_typing_int_min_reducescatter))


@register
class _typing_long_min_reducescatter(ConcreteTemplate):
    key = globals()["long_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_min_reducescatter, types.Function(_typing_long_min_reducescatter))


@register
class _typing_longlong_min_reducescatter(ConcreteTemplate):
    key = globals()["longlong_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_min_reducescatter, types.Function(_typing_longlong_min_reducescatter))


@register
class _typing_bfloat16_min_reducescatter(ConcreteTemplate):
    key = globals()["bfloat16_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_min_reducescatter, types.Function(_typing_bfloat16_min_reducescatter))


@register
class _typing_half_min_reducescatter(ConcreteTemplate):
    key = globals()["half_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_min_reducescatter, types.Function(_typing_half_min_reducescatter))


@register
class _typing_float_min_reducescatter(ConcreteTemplate):
    key = globals()["float_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_min_reducescatter, types.Function(_typing_float_min_reducescatter))


@register
class _typing_double_min_reducescatter(ConcreteTemplate):
    key = globals()["double_min_reducescatter"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_min_reducescatter, types.Function(_typing_double_min_reducescatter))


@register
class _typing_uchar_sum_reducescatter(ConcreteTemplate):
    key = globals()["uchar_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_sum_reducescatter, types.Function(_typing_uchar_sum_reducescatter))


@register
class _typing_ushort_sum_reducescatter(ConcreteTemplate):
    key = globals()["ushort_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_sum_reducescatter, types.Function(_typing_ushort_sum_reducescatter))


@register
class _typing_uint_sum_reducescatter(ConcreteTemplate):
    key = globals()["uint_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_sum_reducescatter, types.Function(_typing_uint_sum_reducescatter))


@register
class _typing_ulong_sum_reducescatter(ConcreteTemplate):
    key = globals()["ulong_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_sum_reducescatter, types.Function(_typing_ulong_sum_reducescatter))


@register
class _typing_ulonglong_sum_reducescatter(ConcreteTemplate):
    key = globals()["ulonglong_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_sum_reducescatter, types.Function(_typing_ulonglong_sum_reducescatter))


@register
class _typing_int8_sum_reducescatter(ConcreteTemplate):
    key = globals()["int8_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_sum_reducescatter, types.Function(_typing_int8_sum_reducescatter))


@register
class _typing_int16_sum_reducescatter(ConcreteTemplate):
    key = globals()["int16_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_sum_reducescatter, types.Function(_typing_int16_sum_reducescatter))


@register
class _typing_int32_sum_reducescatter(ConcreteTemplate):
    key = globals()["int32_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_sum_reducescatter, types.Function(_typing_int32_sum_reducescatter))


@register
class _typing_int64_sum_reducescatter(ConcreteTemplate):
    key = globals()["int64_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_sum_reducescatter, types.Function(_typing_int64_sum_reducescatter))


@register
class _typing_uint8_sum_reducescatter(ConcreteTemplate):
    key = globals()["uint8_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_sum_reducescatter, types.Function(_typing_uint8_sum_reducescatter))


@register
class _typing_uint16_sum_reducescatter(ConcreteTemplate):
    key = globals()["uint16_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_sum_reducescatter, types.Function(_typing_uint16_sum_reducescatter))


@register
class _typing_uint32_sum_reducescatter(ConcreteTemplate):
    key = globals()["uint32_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_sum_reducescatter, types.Function(_typing_uint32_sum_reducescatter))


@register
class _typing_uint64_sum_reducescatter(ConcreteTemplate):
    key = globals()["uint64_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_sum_reducescatter, types.Function(_typing_uint64_sum_reducescatter))


@register
class _typing_size_sum_reducescatter(ConcreteTemplate):
    key = globals()["size_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_sum_reducescatter, types.Function(_typing_size_sum_reducescatter))


@register
class _typing_char_sum_reducescatter(ConcreteTemplate):
    key = globals()["char_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_sum_reducescatter, types.Function(_typing_char_sum_reducescatter))


@register
class _typing_schar_sum_reducescatter(ConcreteTemplate):
    key = globals()["schar_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_sum_reducescatter, types.Function(_typing_schar_sum_reducescatter))


@register
class _typing_short_sum_reducescatter(ConcreteTemplate):
    key = globals()["short_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_sum_reducescatter, types.Function(_typing_short_sum_reducescatter))


@register
class _typing_int_sum_reducescatter(ConcreteTemplate):
    key = globals()["int_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_sum_reducescatter, types.Function(_typing_int_sum_reducescatter))


@register
class _typing_long_sum_reducescatter(ConcreteTemplate):
    key = globals()["long_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_sum_reducescatter, types.Function(_typing_long_sum_reducescatter))


@register
class _typing_longlong_sum_reducescatter(ConcreteTemplate):
    key = globals()["longlong_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_sum_reducescatter, types.Function(_typing_longlong_sum_reducescatter))


@register
class _typing_bfloat16_sum_reducescatter(ConcreteTemplate):
    key = globals()["bfloat16_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_sum_reducescatter, types.Function(_typing_bfloat16_sum_reducescatter))


@register
class _typing_half_sum_reducescatter(ConcreteTemplate):
    key = globals()["half_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_sum_reducescatter, types.Function(_typing_half_sum_reducescatter))


@register
class _typing_float_sum_reducescatter(ConcreteTemplate):
    key = globals()["float_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_sum_reducescatter, types.Function(_typing_float_sum_reducescatter))


@register
class _typing_double_sum_reducescatter(ConcreteTemplate):
    key = globals()["double_sum_reducescatter"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_sum_reducescatter, types.Function(_typing_double_sum_reducescatter))


@register
class _typing_uchar_prod_reducescatter(ConcreteTemplate):
    key = globals()["uchar_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_prod_reducescatter, types.Function(_typing_uchar_prod_reducescatter))


@register
class _typing_ushort_prod_reducescatter(ConcreteTemplate):
    key = globals()["ushort_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_prod_reducescatter, types.Function(_typing_ushort_prod_reducescatter))


@register
class _typing_uint_prod_reducescatter(ConcreteTemplate):
    key = globals()["uint_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_prod_reducescatter, types.Function(_typing_uint_prod_reducescatter))


@register
class _typing_ulong_prod_reducescatter(ConcreteTemplate):
    key = globals()["ulong_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_prod_reducescatter, types.Function(_typing_ulong_prod_reducescatter))


@register
class _typing_ulonglong_prod_reducescatter(ConcreteTemplate):
    key = globals()["ulonglong_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_prod_reducescatter, types.Function(_typing_ulonglong_prod_reducescatter))


@register
class _typing_int8_prod_reducescatter(ConcreteTemplate):
    key = globals()["int8_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_prod_reducescatter, types.Function(_typing_int8_prod_reducescatter))


@register
class _typing_int16_prod_reducescatter(ConcreteTemplate):
    key = globals()["int16_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_prod_reducescatter, types.Function(_typing_int16_prod_reducescatter))


@register
class _typing_int32_prod_reducescatter(ConcreteTemplate):
    key = globals()["int32_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_prod_reducescatter, types.Function(_typing_int32_prod_reducescatter))


@register
class _typing_int64_prod_reducescatter(ConcreteTemplate):
    key = globals()["int64_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_prod_reducescatter, types.Function(_typing_int64_prod_reducescatter))


@register
class _typing_uint8_prod_reducescatter(ConcreteTemplate):
    key = globals()["uint8_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_prod_reducescatter, types.Function(_typing_uint8_prod_reducescatter))


@register
class _typing_uint16_prod_reducescatter(ConcreteTemplate):
    key = globals()["uint16_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_prod_reducescatter, types.Function(_typing_uint16_prod_reducescatter))


@register
class _typing_uint32_prod_reducescatter(ConcreteTemplate):
    key = globals()["uint32_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_prod_reducescatter, types.Function(_typing_uint32_prod_reducescatter))


@register
class _typing_uint64_prod_reducescatter(ConcreteTemplate):
    key = globals()["uint64_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_prod_reducescatter, types.Function(_typing_uint64_prod_reducescatter))


@register
class _typing_size_prod_reducescatter(ConcreteTemplate):
    key = globals()["size_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_prod_reducescatter, types.Function(_typing_size_prod_reducescatter))


@register
class _typing_char_prod_reducescatter(ConcreteTemplate):
    key = globals()["char_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_prod_reducescatter, types.Function(_typing_char_prod_reducescatter))


@register
class _typing_schar_prod_reducescatter(ConcreteTemplate):
    key = globals()["schar_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_prod_reducescatter, types.Function(_typing_schar_prod_reducescatter))


@register
class _typing_short_prod_reducescatter(ConcreteTemplate):
    key = globals()["short_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_prod_reducescatter, types.Function(_typing_short_prod_reducescatter))


@register
class _typing_int_prod_reducescatter(ConcreteTemplate):
    key = globals()["int_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_prod_reducescatter, types.Function(_typing_int_prod_reducescatter))


@register
class _typing_long_prod_reducescatter(ConcreteTemplate):
    key = globals()["long_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_prod_reducescatter, types.Function(_typing_long_prod_reducescatter))


@register
class _typing_longlong_prod_reducescatter(ConcreteTemplate):
    key = globals()["longlong_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_prod_reducescatter, types.Function(_typing_longlong_prod_reducescatter))


@register
class _typing_bfloat16_prod_reducescatter(ConcreteTemplate):
    key = globals()["bfloat16_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_prod_reducescatter, types.Function(_typing_bfloat16_prod_reducescatter))


@register
class _typing_half_prod_reducescatter(ConcreteTemplate):
    key = globals()["half_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_prod_reducescatter, types.Function(_typing_half_prod_reducescatter))


@register
class _typing_float_prod_reducescatter(ConcreteTemplate):
    key = globals()["float_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_prod_reducescatter, types.Function(_typing_float_prod_reducescatter))


@register
class _typing_double_prod_reducescatter(ConcreteTemplate):
    key = globals()["double_prod_reducescatter"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_prod_reducescatter, types.Function(_typing_double_prod_reducescatter))


@register
class _typing_vendor_get_version_info(ConcreteTemplate):
    key = globals()["vendor_get_version_info"]
    cases = [signature(void, CPointer(int32), CPointer(int32), CPointer(int32))]

register_global(vendor_get_version_info, types.Function(_typing_vendor_get_version_info))


@register
class _typing_signal_op(ConcreteTemplate):
    key = globals()["signal_op"]
    cases = [signature(void, CPointer(uint64), uint64, int32, int32)]

register_global(signal_op, types.Function(_typing_signal_op))


@register
class _typing_mc_ptr(ConcreteTemplate):
    key = globals()["mc_ptr"]
    cases = [signature(CPointer(void), int32, CPointer(void))]

register_global(mc_ptr, types.Function(_typing_mc_ptr))


@register
class _typing_bfloat16_put_warp(ConcreteTemplate):
    key = globals()["bfloat16_put_warp"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)]

register_global(bfloat16_put_warp, types.Function(_typing_bfloat16_put_warp))


@register
class _typing_bfloat16_put_block(ConcreteTemplate):
    key = globals()["bfloat16_put_block"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)]

register_global(bfloat16_put_block, types.Function(_typing_bfloat16_put_block))


@register
class _typing_half_put_warp(ConcreteTemplate):
    key = globals()["half_put_warp"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32)]

register_global(half_put_warp, types.Function(_typing_half_put_warp))


@register
class _typing_half_put_block(ConcreteTemplate):
    key = globals()["half_put_block"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32)]

register_global(half_put_block, types.Function(_typing_half_put_block))


@register
class _typing_float_put_warp(ConcreteTemplate):
    key = globals()["float_put_warp"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32)]

register_global(float_put_warp, types.Function(_typing_float_put_warp))


@register
class _typing_float_put_block(ConcreteTemplate):
    key = globals()["float_put_block"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32)]

register_global(float_put_block, types.Function(_typing_float_put_block))


@register
class _typing_double_put_warp(ConcreteTemplate):
    key = globals()["double_put_warp"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32)]

register_global(double_put_warp, types.Function(_typing_double_put_warp))


@register
class _typing_double_put_block(ConcreteTemplate):
    key = globals()["double_put_block"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32)]

register_global(double_put_block, types.Function(_typing_double_put_block))


@register
class _typing_char_put_warp(ConcreteTemplate):
    key = globals()["char_put_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(char_put_warp, types.Function(_typing_char_put_warp))


@register
class _typing_char_put_block(ConcreteTemplate):
    key = globals()["char_put_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(char_put_block, types.Function(_typing_char_put_block))


@register
class _typing_short_put_warp(ConcreteTemplate):
    key = globals()["short_put_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(short_put_warp, types.Function(_typing_short_put_warp))


@register
class _typing_short_put_block(ConcreteTemplate):
    key = globals()["short_put_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(short_put_block, types.Function(_typing_short_put_block))


@register
class _typing_schar_put_warp(ConcreteTemplate):
    key = globals()["schar_put_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(schar_put_warp, types.Function(_typing_schar_put_warp))


@register
class _typing_schar_put_block(ConcreteTemplate):
    key = globals()["schar_put_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(schar_put_block, types.Function(_typing_schar_put_block))


@register
class _typing_int_put_warp(ConcreteTemplate):
    key = globals()["int_put_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int_put_warp, types.Function(_typing_int_put_warp))


@register
class _typing_int_put_block(ConcreteTemplate):
    key = globals()["int_put_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int_put_block, types.Function(_typing_int_put_block))


@register
class _typing_long_put_warp(ConcreteTemplate):
    key = globals()["long_put_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(long_put_warp, types.Function(_typing_long_put_warp))


@register
class _typing_long_put_block(ConcreteTemplate):
    key = globals()["long_put_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(long_put_block, types.Function(_typing_long_put_block))


@register
class _typing_longlong_put_warp(ConcreteTemplate):
    key = globals()["longlong_put_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(longlong_put_warp, types.Function(_typing_longlong_put_warp))


@register
class _typing_longlong_put_block(ConcreteTemplate):
    key = globals()["longlong_put_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(longlong_put_block, types.Function(_typing_longlong_put_block))


@register
class _typing_uchar_put_warp(ConcreteTemplate):
    key = globals()["uchar_put_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uchar_put_warp, types.Function(_typing_uchar_put_warp))


@register
class _typing_uchar_put_block(ConcreteTemplate):
    key = globals()["uchar_put_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uchar_put_block, types.Function(_typing_uchar_put_block))


@register
class _typing_ushort_put_warp(ConcreteTemplate):
    key = globals()["ushort_put_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(ushort_put_warp, types.Function(_typing_ushort_put_warp))


@register
class _typing_ushort_put_block(ConcreteTemplate):
    key = globals()["ushort_put_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(ushort_put_block, types.Function(_typing_ushort_put_block))


@register
class _typing_uint_put_warp(ConcreteTemplate):
    key = globals()["uint_put_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint_put_warp, types.Function(_typing_uint_put_warp))


@register
class _typing_uint_put_block(ConcreteTemplate):
    key = globals()["uint_put_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint_put_block, types.Function(_typing_uint_put_block))


@register
class _typing_ulong_put_warp(ConcreteTemplate):
    key = globals()["ulong_put_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulong_put_warp, types.Function(_typing_ulong_put_warp))


@register
class _typing_ulong_put_block(ConcreteTemplate):
    key = globals()["ulong_put_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulong_put_block, types.Function(_typing_ulong_put_block))


@register
class _typing_ulonglong_put_warp(ConcreteTemplate):
    key = globals()["ulonglong_put_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulonglong_put_warp, types.Function(_typing_ulonglong_put_warp))


@register
class _typing_ulonglong_put_block(ConcreteTemplate):
    key = globals()["ulonglong_put_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulonglong_put_block, types.Function(_typing_ulonglong_put_block))


@register
class _typing_int8_put_warp(ConcreteTemplate):
    key = globals()["int8_put_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(int8_put_warp, types.Function(_typing_int8_put_warp))


@register
class _typing_int8_put_block(ConcreteTemplate):
    key = globals()["int8_put_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(int8_put_block, types.Function(_typing_int8_put_block))


@register
class _typing_int16_put_warp(ConcreteTemplate):
    key = globals()["int16_put_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(int16_put_warp, types.Function(_typing_int16_put_warp))


@register
class _typing_int16_put_block(ConcreteTemplate):
    key = globals()["int16_put_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(int16_put_block, types.Function(_typing_int16_put_block))


@register
class _typing_int32_put_warp(ConcreteTemplate):
    key = globals()["int32_put_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int32_put_warp, types.Function(_typing_int32_put_warp))


@register
class _typing_int32_put_block(ConcreteTemplate):
    key = globals()["int32_put_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int32_put_block, types.Function(_typing_int32_put_block))


@register
class _typing_int64_put_warp(ConcreteTemplate):
    key = globals()["int64_put_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(int64_put_warp, types.Function(_typing_int64_put_warp))


@register
class _typing_int64_put_block(ConcreteTemplate):
    key = globals()["int64_put_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(int64_put_block, types.Function(_typing_int64_put_block))


@register
class _typing_uint8_put_warp(ConcreteTemplate):
    key = globals()["uint8_put_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uint8_put_warp, types.Function(_typing_uint8_put_warp))


@register
class _typing_uint8_put_block(ConcreteTemplate):
    key = globals()["uint8_put_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uint8_put_block, types.Function(_typing_uint8_put_block))


@register
class _typing_uint16_put_warp(ConcreteTemplate):
    key = globals()["uint16_put_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(uint16_put_warp, types.Function(_typing_uint16_put_warp))


@register
class _typing_uint16_put_block(ConcreteTemplate):
    key = globals()["uint16_put_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(uint16_put_block, types.Function(_typing_uint16_put_block))


@register
class _typing_uint32_put_warp(ConcreteTemplate):
    key = globals()["uint32_put_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint32_put_warp, types.Function(_typing_uint32_put_warp))


@register
class _typing_uint32_put_block(ConcreteTemplate):
    key = globals()["uint32_put_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint32_put_block, types.Function(_typing_uint32_put_block))


@register
class _typing_uint64_put_warp(ConcreteTemplate):
    key = globals()["uint64_put_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(uint64_put_warp, types.Function(_typing_uint64_put_warp))


@register
class _typing_uint64_put_block(ConcreteTemplate):
    key = globals()["uint64_put_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(uint64_put_block, types.Function(_typing_uint64_put_block))


@register
class _typing_size_put_warp(ConcreteTemplate):
    key = globals()["size_put_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(size_put_warp, types.Function(_typing_size_put_warp))


@register
class _typing_size_put_block(ConcreteTemplate):
    key = globals()["size_put_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(size_put_block, types.Function(_typing_size_put_block))


@register
class _typing_ptrdiff_put_warp(ConcreteTemplate):
    key = globals()["ptrdiff_put_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(ptrdiff_put_warp, types.Function(_typing_ptrdiff_put_warp))


@register
class _typing_ptrdiff_put_block(ConcreteTemplate):
    key = globals()["ptrdiff_put_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(ptrdiff_put_block, types.Function(_typing_ptrdiff_put_block))


@register
class _typing_nvshmemi_bfloat16_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_bfloat16_put_signal_warp"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_bfloat16_put_signal_warp, types.Function(_typing_nvshmemi_bfloat16_put_signal_warp))


@register
class _typing_nvshmemi_half_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_half_put_signal_warp"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_half_put_signal_warp, types.Function(_typing_nvshmemi_half_put_signal_warp))


@register
class _typing_nvshmemi_float_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_float_put_signal_warp"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_float_put_signal_warp, types.Function(_typing_nvshmemi_float_put_signal_warp))


@register
class _typing_nvshmemi_double_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_double_put_signal_warp"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_double_put_signal_warp, types.Function(_typing_nvshmemi_double_put_signal_warp))


@register
class _typing_nvshmemi_char_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_char_put_signal_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_char_put_signal_warp, types.Function(_typing_nvshmemi_char_put_signal_warp))


@register
class _typing_nvshmemi_short_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_short_put_signal_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_short_put_signal_warp, types.Function(_typing_nvshmemi_short_put_signal_warp))


@register
class _typing_nvshmemi_schar_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_schar_put_signal_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_schar_put_signal_warp, types.Function(_typing_nvshmemi_schar_put_signal_warp))


@register
class _typing_nvshmemi_int_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_int_put_signal_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_int_put_signal_warp, types.Function(_typing_nvshmemi_int_put_signal_warp))


@register
class _typing_nvshmemi_long_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_long_put_signal_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_long_put_signal_warp, types.Function(_typing_nvshmemi_long_put_signal_warp))


@register
class _typing_nvshmemi_longlong_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_longlong_put_signal_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_longlong_put_signal_warp, types.Function(_typing_nvshmemi_longlong_put_signal_warp))


@register
class _typing_nvshmemi_uchar_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_uchar_put_signal_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_uchar_put_signal_warp, types.Function(_typing_nvshmemi_uchar_put_signal_warp))


@register
class _typing_nvshmemi_ushort_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_ushort_put_signal_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_ushort_put_signal_warp, types.Function(_typing_nvshmemi_ushort_put_signal_warp))


@register
class _typing_nvshmemi_uint_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_uint_put_signal_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_uint_put_signal_warp, types.Function(_typing_nvshmemi_uint_put_signal_warp))


@register
class _typing_nvshmemi_ulong_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_ulong_put_signal_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_ulong_put_signal_warp, types.Function(_typing_nvshmemi_ulong_put_signal_warp))


@register
class _typing_nvshmemi_ulonglong_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_ulonglong_put_signal_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_ulonglong_put_signal_warp, types.Function(_typing_nvshmemi_ulonglong_put_signal_warp))


@register
class _typing_nvshmemi_int8_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_int8_put_signal_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_int8_put_signal_warp, types.Function(_typing_nvshmemi_int8_put_signal_warp))


@register
class _typing_nvshmemi_int16_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_int16_put_signal_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_int16_put_signal_warp, types.Function(_typing_nvshmemi_int16_put_signal_warp))


@register
class _typing_nvshmemi_int32_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_int32_put_signal_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_int32_put_signal_warp, types.Function(_typing_nvshmemi_int32_put_signal_warp))


@register
class _typing_nvshmemi_int64_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_int64_put_signal_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_int64_put_signal_warp, types.Function(_typing_nvshmemi_int64_put_signal_warp))


@register
class _typing_nvshmemi_uint8_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_uint8_put_signal_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_uint8_put_signal_warp, types.Function(_typing_nvshmemi_uint8_put_signal_warp))


@register
class _typing_nvshmemi_uint16_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_uint16_put_signal_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_uint16_put_signal_warp, types.Function(_typing_nvshmemi_uint16_put_signal_warp))


@register
class _typing_nvshmemi_uint32_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_uint32_put_signal_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_uint32_put_signal_warp, types.Function(_typing_nvshmemi_uint32_put_signal_warp))


@register
class _typing_nvshmemi_uint64_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_uint64_put_signal_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_uint64_put_signal_warp, types.Function(_typing_nvshmemi_uint64_put_signal_warp))


@register
class _typing_nvshmemi_size_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_size_put_signal_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_size_put_signal_warp, types.Function(_typing_nvshmemi_size_put_signal_warp))


@register
class _typing_nvshmemi_ptrdiff_put_signal_warp(ConcreteTemplate):
    key = globals()["nvshmemi_ptrdiff_put_signal_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_ptrdiff_put_signal_warp, types.Function(_typing_nvshmemi_ptrdiff_put_signal_warp))


@register
class _typing_nvshmemi_bfloat16_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_bfloat16_put_signal_block"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_bfloat16_put_signal_block, types.Function(_typing_nvshmemi_bfloat16_put_signal_block))


@register
class _typing_nvshmemi_half_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_half_put_signal_block"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_half_put_signal_block, types.Function(_typing_nvshmemi_half_put_signal_block))


@register
class _typing_nvshmemi_float_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_float_put_signal_block"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_float_put_signal_block, types.Function(_typing_nvshmemi_float_put_signal_block))


@register
class _typing_nvshmemi_double_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_double_put_signal_block"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_double_put_signal_block, types.Function(_typing_nvshmemi_double_put_signal_block))


@register
class _typing_nvshmemi_char_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_char_put_signal_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_char_put_signal_block, types.Function(_typing_nvshmemi_char_put_signal_block))


@register
class _typing_nvshmemi_short_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_short_put_signal_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_short_put_signal_block, types.Function(_typing_nvshmemi_short_put_signal_block))


@register
class _typing_nvshmemi_schar_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_schar_put_signal_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_schar_put_signal_block, types.Function(_typing_nvshmemi_schar_put_signal_block))


@register
class _typing_nvshmemi_int_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_int_put_signal_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_int_put_signal_block, types.Function(_typing_nvshmemi_int_put_signal_block))


@register
class _typing_nvshmemi_long_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_long_put_signal_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_long_put_signal_block, types.Function(_typing_nvshmemi_long_put_signal_block))


@register
class _typing_nvshmemi_longlong_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_longlong_put_signal_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_longlong_put_signal_block, types.Function(_typing_nvshmemi_longlong_put_signal_block))


@register
class _typing_nvshmemi_uchar_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_uchar_put_signal_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_uchar_put_signal_block, types.Function(_typing_nvshmemi_uchar_put_signal_block))


@register
class _typing_nvshmemi_ushort_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_ushort_put_signal_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_ushort_put_signal_block, types.Function(_typing_nvshmemi_ushort_put_signal_block))


@register
class _typing_nvshmemi_uint_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_uint_put_signal_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_uint_put_signal_block, types.Function(_typing_nvshmemi_uint_put_signal_block))


@register
class _typing_nvshmemi_ulong_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_ulong_put_signal_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_ulong_put_signal_block, types.Function(_typing_nvshmemi_ulong_put_signal_block))


@register
class _typing_nvshmemi_ulonglong_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_ulonglong_put_signal_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_ulonglong_put_signal_block, types.Function(_typing_nvshmemi_ulonglong_put_signal_block))


@register
class _typing_nvshmemi_int8_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_int8_put_signal_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_int8_put_signal_block, types.Function(_typing_nvshmemi_int8_put_signal_block))


@register
class _typing_nvshmemi_int16_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_int16_put_signal_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_int16_put_signal_block, types.Function(_typing_nvshmemi_int16_put_signal_block))


@register
class _typing_nvshmemi_int32_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_int32_put_signal_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_int32_put_signal_block, types.Function(_typing_nvshmemi_int32_put_signal_block))


@register
class _typing_nvshmemi_int64_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_int64_put_signal_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_int64_put_signal_block, types.Function(_typing_nvshmemi_int64_put_signal_block))


@register
class _typing_nvshmemi_uint8_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_uint8_put_signal_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_uint8_put_signal_block, types.Function(_typing_nvshmemi_uint8_put_signal_block))


@register
class _typing_nvshmemi_uint16_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_uint16_put_signal_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_uint16_put_signal_block, types.Function(_typing_nvshmemi_uint16_put_signal_block))


@register
class _typing_nvshmemi_uint32_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_uint32_put_signal_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_uint32_put_signal_block, types.Function(_typing_nvshmemi_uint32_put_signal_block))


@register
class _typing_nvshmemi_uint64_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_uint64_put_signal_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_uint64_put_signal_block, types.Function(_typing_nvshmemi_uint64_put_signal_block))


@register
class _typing_nvshmemi_size_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_size_put_signal_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_size_put_signal_block, types.Function(_typing_nvshmemi_size_put_signal_block))


@register
class _typing_nvshmemi_ptrdiff_put_signal_block(ConcreteTemplate):
    key = globals()["nvshmemi_ptrdiff_put_signal_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, bool_)]

register_global(nvshmemi_ptrdiff_put_signal_block, types.Function(_typing_nvshmemi_ptrdiff_put_signal_block))


@register
class _typing_bfloat16_put_signal_warp(ConcreteTemplate):
    key = globals()["bfloat16_put_signal_warp"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(bfloat16_put_signal_warp, types.Function(_typing_bfloat16_put_signal_warp))


@register
class _typing_half_put_signal_warp(ConcreteTemplate):
    key = globals()["half_put_signal_warp"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(half_put_signal_warp, types.Function(_typing_half_put_signal_warp))


@register
class _typing_float_put_signal_warp(ConcreteTemplate):
    key = globals()["float_put_signal_warp"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(float_put_signal_warp, types.Function(_typing_float_put_signal_warp))


@register
class _typing_double_put_signal_warp(ConcreteTemplate):
    key = globals()["double_put_signal_warp"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(double_put_signal_warp, types.Function(_typing_double_put_signal_warp))


@register
class _typing_char_put_signal_warp(ConcreteTemplate):
    key = globals()["char_put_signal_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(char_put_signal_warp, types.Function(_typing_char_put_signal_warp))


@register
class _typing_short_put_signal_warp(ConcreteTemplate):
    key = globals()["short_put_signal_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(short_put_signal_warp, types.Function(_typing_short_put_signal_warp))


@register
class _typing_schar_put_signal_warp(ConcreteTemplate):
    key = globals()["schar_put_signal_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(schar_put_signal_warp, types.Function(_typing_schar_put_signal_warp))


@register
class _typing_int_put_signal_warp(ConcreteTemplate):
    key = globals()["int_put_signal_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int_put_signal_warp, types.Function(_typing_int_put_signal_warp))


@register
class _typing_long_put_signal_warp(ConcreteTemplate):
    key = globals()["long_put_signal_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(long_put_signal_warp, types.Function(_typing_long_put_signal_warp))


@register
class _typing_longlong_put_signal_warp(ConcreteTemplate):
    key = globals()["longlong_put_signal_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(longlong_put_signal_warp, types.Function(_typing_longlong_put_signal_warp))


@register
class _typing_uchar_put_signal_warp(ConcreteTemplate):
    key = globals()["uchar_put_signal_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uchar_put_signal_warp, types.Function(_typing_uchar_put_signal_warp))


@register
class _typing_ushort_put_signal_warp(ConcreteTemplate):
    key = globals()["ushort_put_signal_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ushort_put_signal_warp, types.Function(_typing_ushort_put_signal_warp))


@register
class _typing_uint_put_signal_warp(ConcreteTemplate):
    key = globals()["uint_put_signal_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint_put_signal_warp, types.Function(_typing_uint_put_signal_warp))


@register
class _typing_ulong_put_signal_warp(ConcreteTemplate):
    key = globals()["ulong_put_signal_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ulong_put_signal_warp, types.Function(_typing_ulong_put_signal_warp))


@register
class _typing_ulonglong_put_signal_warp(ConcreteTemplate):
    key = globals()["ulonglong_put_signal_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ulonglong_put_signal_warp, types.Function(_typing_ulonglong_put_signal_warp))


@register
class _typing_int8_put_signal_warp(ConcreteTemplate):
    key = globals()["int8_put_signal_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int8_put_signal_warp, types.Function(_typing_int8_put_signal_warp))


@register
class _typing_int16_put_signal_warp(ConcreteTemplate):
    key = globals()["int16_put_signal_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int16_put_signal_warp, types.Function(_typing_int16_put_signal_warp))


@register
class _typing_int32_put_signal_warp(ConcreteTemplate):
    key = globals()["int32_put_signal_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int32_put_signal_warp, types.Function(_typing_int32_put_signal_warp))


@register
class _typing_int64_put_signal_warp(ConcreteTemplate):
    key = globals()["int64_put_signal_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int64_put_signal_warp, types.Function(_typing_int64_put_signal_warp))


@register
class _typing_uint8_put_signal_warp(ConcreteTemplate):
    key = globals()["uint8_put_signal_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint8_put_signal_warp, types.Function(_typing_uint8_put_signal_warp))


@register
class _typing_uint16_put_signal_warp(ConcreteTemplate):
    key = globals()["uint16_put_signal_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint16_put_signal_warp, types.Function(_typing_uint16_put_signal_warp))


@register
class _typing_uint32_put_signal_warp(ConcreteTemplate):
    key = globals()["uint32_put_signal_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint32_put_signal_warp, types.Function(_typing_uint32_put_signal_warp))


@register
class _typing_uint64_put_signal_warp(ConcreteTemplate):
    key = globals()["uint64_put_signal_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint64_put_signal_warp, types.Function(_typing_uint64_put_signal_warp))


@register
class _typing_size_put_signal_warp(ConcreteTemplate):
    key = globals()["size_put_signal_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(size_put_signal_warp, types.Function(_typing_size_put_signal_warp))


@register
class _typing_ptrdiff_put_signal_warp(ConcreteTemplate):
    key = globals()["ptrdiff_put_signal_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ptrdiff_put_signal_warp, types.Function(_typing_ptrdiff_put_signal_warp))


@register
class _typing_bfloat16_put_signal_block(ConcreteTemplate):
    key = globals()["bfloat16_put_signal_block"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(bfloat16_put_signal_block, types.Function(_typing_bfloat16_put_signal_block))


@register
class _typing_half_put_signal_block(ConcreteTemplate):
    key = globals()["half_put_signal_block"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(half_put_signal_block, types.Function(_typing_half_put_signal_block))


@register
class _typing_float_put_signal_block(ConcreteTemplate):
    key = globals()["float_put_signal_block"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(float_put_signal_block, types.Function(_typing_float_put_signal_block))


@register
class _typing_double_put_signal_block(ConcreteTemplate):
    key = globals()["double_put_signal_block"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(double_put_signal_block, types.Function(_typing_double_put_signal_block))


@register
class _typing_char_put_signal_block(ConcreteTemplate):
    key = globals()["char_put_signal_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(char_put_signal_block, types.Function(_typing_char_put_signal_block))


@register
class _typing_short_put_signal_block(ConcreteTemplate):
    key = globals()["short_put_signal_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(short_put_signal_block, types.Function(_typing_short_put_signal_block))


@register
class _typing_schar_put_signal_block(ConcreteTemplate):
    key = globals()["schar_put_signal_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(schar_put_signal_block, types.Function(_typing_schar_put_signal_block))


@register
class _typing_int_put_signal_block(ConcreteTemplate):
    key = globals()["int_put_signal_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int_put_signal_block, types.Function(_typing_int_put_signal_block))


@register
class _typing_long_put_signal_block(ConcreteTemplate):
    key = globals()["long_put_signal_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(long_put_signal_block, types.Function(_typing_long_put_signal_block))


@register
class _typing_longlong_put_signal_block(ConcreteTemplate):
    key = globals()["longlong_put_signal_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(longlong_put_signal_block, types.Function(_typing_longlong_put_signal_block))


@register
class _typing_uchar_put_signal_block(ConcreteTemplate):
    key = globals()["uchar_put_signal_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uchar_put_signal_block, types.Function(_typing_uchar_put_signal_block))


@register
class _typing_ushort_put_signal_block(ConcreteTemplate):
    key = globals()["ushort_put_signal_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ushort_put_signal_block, types.Function(_typing_ushort_put_signal_block))


@register
class _typing_uint_put_signal_block(ConcreteTemplate):
    key = globals()["uint_put_signal_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint_put_signal_block, types.Function(_typing_uint_put_signal_block))


@register
class _typing_ulong_put_signal_block(ConcreteTemplate):
    key = globals()["ulong_put_signal_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ulong_put_signal_block, types.Function(_typing_ulong_put_signal_block))


@register
class _typing_ulonglong_put_signal_block(ConcreteTemplate):
    key = globals()["ulonglong_put_signal_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ulonglong_put_signal_block, types.Function(_typing_ulonglong_put_signal_block))


@register
class _typing_int8_put_signal_block(ConcreteTemplate):
    key = globals()["int8_put_signal_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int8_put_signal_block, types.Function(_typing_int8_put_signal_block))


@register
class _typing_int16_put_signal_block(ConcreteTemplate):
    key = globals()["int16_put_signal_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int16_put_signal_block, types.Function(_typing_int16_put_signal_block))


@register
class _typing_int32_put_signal_block(ConcreteTemplate):
    key = globals()["int32_put_signal_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int32_put_signal_block, types.Function(_typing_int32_put_signal_block))


@register
class _typing_int64_put_signal_block(ConcreteTemplate):
    key = globals()["int64_put_signal_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int64_put_signal_block, types.Function(_typing_int64_put_signal_block))


@register
class _typing_uint8_put_signal_block(ConcreteTemplate):
    key = globals()["uint8_put_signal_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint8_put_signal_block, types.Function(_typing_uint8_put_signal_block))


@register
class _typing_uint16_put_signal_block(ConcreteTemplate):
    key = globals()["uint16_put_signal_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint16_put_signal_block, types.Function(_typing_uint16_put_signal_block))


@register
class _typing_uint32_put_signal_block(ConcreteTemplate):
    key = globals()["uint32_put_signal_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint32_put_signal_block, types.Function(_typing_uint32_put_signal_block))


@register
class _typing_uint64_put_signal_block(ConcreteTemplate):
    key = globals()["uint64_put_signal_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint64_put_signal_block, types.Function(_typing_uint64_put_signal_block))


@register
class _typing_size_put_signal_block(ConcreteTemplate):
    key = globals()["size_put_signal_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(size_put_signal_block, types.Function(_typing_size_put_signal_block))


@register
class _typing_ptrdiff_put_signal_block(ConcreteTemplate):
    key = globals()["ptrdiff_put_signal_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ptrdiff_put_signal_block, types.Function(_typing_ptrdiff_put_signal_block))


@register
class _typing_putmem_signal_warp(ConcreteTemplate):
    key = globals()["putmem_signal_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(putmem_signal_warp, types.Function(_typing_putmem_signal_warp))


@register
class _typing_putmem_signal_block(ConcreteTemplate):
    key = globals()["putmem_signal_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(putmem_signal_block, types.Function(_typing_putmem_signal_block))


@register
class _typing_put8_signal_warp(ConcreteTemplate):
    key = globals()["put8_signal_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put8_signal_warp, types.Function(_typing_put8_signal_warp))


@register
class _typing_put6_signal_warp(ConcreteTemplate):
    key = globals()["put6_signal_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put6_signal_warp, types.Function(_typing_put6_signal_warp))


@register
class _typing_put32_signal_warp(ConcreteTemplate):
    key = globals()["put32_signal_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put32_signal_warp, types.Function(_typing_put32_signal_warp))


@register
class _typing_put64_signal_warp(ConcreteTemplate):
    key = globals()["put64_signal_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put64_signal_warp, types.Function(_typing_put64_signal_warp))


@register
class _typing_put128_signal_warp(ConcreteTemplate):
    key = globals()["put128_signal_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put128_signal_warp, types.Function(_typing_put128_signal_warp))


@register
class _typing_put8_signal_block(ConcreteTemplate):
    key = globals()["put8_signal_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put8_signal_block, types.Function(_typing_put8_signal_block))


@register
class _typing_put6_signal_block(ConcreteTemplate):
    key = globals()["put6_signal_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put6_signal_block, types.Function(_typing_put6_signal_block))


@register
class _typing_put32_signal_block(ConcreteTemplate):
    key = globals()["put32_signal_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put32_signal_block, types.Function(_typing_put32_signal_block))


@register
class _typing_put64_signal_block(ConcreteTemplate):
    key = globals()["put64_signal_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put64_signal_block, types.Function(_typing_put64_signal_block))


@register
class _typing_put128_signal_block(ConcreteTemplate):
    key = globals()["put128_signal_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put128_signal_block, types.Function(_typing_put128_signal_block))


@register
class _typing_bfloat16_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["bfloat16_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(bfloat16_put_signal_nbi_warp, types.Function(_typing_bfloat16_put_signal_nbi_warp))


@register
class _typing_half_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["half_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(half_put_signal_nbi_warp, types.Function(_typing_half_put_signal_nbi_warp))


@register
class _typing_float_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["float_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(float_put_signal_nbi_warp, types.Function(_typing_float_put_signal_nbi_warp))


@register
class _typing_double_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["double_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(double_put_signal_nbi_warp, types.Function(_typing_double_put_signal_nbi_warp))


@register
class _typing_char_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["char_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(char_put_signal_nbi_warp, types.Function(_typing_char_put_signal_nbi_warp))


@register
class _typing_short_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["short_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(short_put_signal_nbi_warp, types.Function(_typing_short_put_signal_nbi_warp))


@register
class _typing_schar_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["schar_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(schar_put_signal_nbi_warp, types.Function(_typing_schar_put_signal_nbi_warp))


@register
class _typing_int_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["int_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int_put_signal_nbi_warp, types.Function(_typing_int_put_signal_nbi_warp))


@register
class _typing_long_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["long_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(long_put_signal_nbi_warp, types.Function(_typing_long_put_signal_nbi_warp))


@register
class _typing_longlong_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["longlong_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(longlong_put_signal_nbi_warp, types.Function(_typing_longlong_put_signal_nbi_warp))


@register
class _typing_uchar_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["uchar_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uchar_put_signal_nbi_warp, types.Function(_typing_uchar_put_signal_nbi_warp))


@register
class _typing_ushort_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["ushort_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ushort_put_signal_nbi_warp, types.Function(_typing_ushort_put_signal_nbi_warp))


@register
class _typing_uint_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["uint_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint_put_signal_nbi_warp, types.Function(_typing_uint_put_signal_nbi_warp))


@register
class _typing_ulong_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["ulong_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ulong_put_signal_nbi_warp, types.Function(_typing_ulong_put_signal_nbi_warp))


@register
class _typing_ulonglong_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["ulonglong_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ulonglong_put_signal_nbi_warp, types.Function(_typing_ulonglong_put_signal_nbi_warp))


@register
class _typing_int8_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["int8_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int8_put_signal_nbi_warp, types.Function(_typing_int8_put_signal_nbi_warp))


@register
class _typing_int16_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["int16_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int16_put_signal_nbi_warp, types.Function(_typing_int16_put_signal_nbi_warp))


@register
class _typing_int32_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["int32_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int32_put_signal_nbi_warp, types.Function(_typing_int32_put_signal_nbi_warp))


@register
class _typing_int64_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["int64_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int64_put_signal_nbi_warp, types.Function(_typing_int64_put_signal_nbi_warp))


@register
class _typing_uint8_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["uint8_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint8_put_signal_nbi_warp, types.Function(_typing_uint8_put_signal_nbi_warp))


@register
class _typing_uint16_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["uint16_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint16_put_signal_nbi_warp, types.Function(_typing_uint16_put_signal_nbi_warp))


@register
class _typing_uint32_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["uint32_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint32_put_signal_nbi_warp, types.Function(_typing_uint32_put_signal_nbi_warp))


@register
class _typing_uint64_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["uint64_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint64_put_signal_nbi_warp, types.Function(_typing_uint64_put_signal_nbi_warp))


@register
class _typing_size_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["size_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(size_put_signal_nbi_warp, types.Function(_typing_size_put_signal_nbi_warp))


@register
class _typing_ptrdiff_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["ptrdiff_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ptrdiff_put_signal_nbi_warp, types.Function(_typing_ptrdiff_put_signal_nbi_warp))


@register
class _typing_bfloat16_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["bfloat16_put_signal_nbi_block"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(bfloat16_put_signal_nbi_block, types.Function(_typing_bfloat16_put_signal_nbi_block))


@register
class _typing_half_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["half_put_signal_nbi_block"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(half_put_signal_nbi_block, types.Function(_typing_half_put_signal_nbi_block))


@register
class _typing_float_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["float_put_signal_nbi_block"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(float_put_signal_nbi_block, types.Function(_typing_float_put_signal_nbi_block))


@register
class _typing_double_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["double_put_signal_nbi_block"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(double_put_signal_nbi_block, types.Function(_typing_double_put_signal_nbi_block))


@register
class _typing_char_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["char_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(char_put_signal_nbi_block, types.Function(_typing_char_put_signal_nbi_block))


@register
class _typing_short_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["short_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(short_put_signal_nbi_block, types.Function(_typing_short_put_signal_nbi_block))


@register
class _typing_schar_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["schar_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(schar_put_signal_nbi_block, types.Function(_typing_schar_put_signal_nbi_block))


@register
class _typing_int_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["int_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int_put_signal_nbi_block, types.Function(_typing_int_put_signal_nbi_block))


@register
class _typing_long_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["long_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(long_put_signal_nbi_block, types.Function(_typing_long_put_signal_nbi_block))


@register
class _typing_longlong_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["longlong_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(longlong_put_signal_nbi_block, types.Function(_typing_longlong_put_signal_nbi_block))


@register
class _typing_uchar_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["uchar_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uchar_put_signal_nbi_block, types.Function(_typing_uchar_put_signal_nbi_block))


@register
class _typing_ushort_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["ushort_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ushort_put_signal_nbi_block, types.Function(_typing_ushort_put_signal_nbi_block))


@register
class _typing_uint_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["uint_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint_put_signal_nbi_block, types.Function(_typing_uint_put_signal_nbi_block))


@register
class _typing_ulong_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["ulong_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ulong_put_signal_nbi_block, types.Function(_typing_ulong_put_signal_nbi_block))


@register
class _typing_ulonglong_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["ulonglong_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ulonglong_put_signal_nbi_block, types.Function(_typing_ulonglong_put_signal_nbi_block))


@register
class _typing_int8_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["int8_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int8_put_signal_nbi_block, types.Function(_typing_int8_put_signal_nbi_block))


@register
class _typing_int16_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["int16_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int16_put_signal_nbi_block, types.Function(_typing_int16_put_signal_nbi_block))


@register
class _typing_int32_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["int32_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int32_put_signal_nbi_block, types.Function(_typing_int32_put_signal_nbi_block))


@register
class _typing_int64_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["int64_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(int64_put_signal_nbi_block, types.Function(_typing_int64_put_signal_nbi_block))


@register
class _typing_uint8_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["uint8_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint8_put_signal_nbi_block, types.Function(_typing_uint8_put_signal_nbi_block))


@register
class _typing_uint16_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["uint16_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint16_put_signal_nbi_block, types.Function(_typing_uint16_put_signal_nbi_block))


@register
class _typing_uint32_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["uint32_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint32_put_signal_nbi_block, types.Function(_typing_uint32_put_signal_nbi_block))


@register
class _typing_uint64_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["uint64_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(uint64_put_signal_nbi_block, types.Function(_typing_uint64_put_signal_nbi_block))


@register
class _typing_size_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["size_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(size_put_signal_nbi_block, types.Function(_typing_size_put_signal_nbi_block))


@register
class _typing_ptrdiff_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["ptrdiff_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(ptrdiff_put_signal_nbi_block, types.Function(_typing_ptrdiff_put_signal_nbi_block))


@register
class _typing_putmem_signal_nbi_warp(ConcreteTemplate):
    key = globals()["putmem_signal_nbi_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(putmem_signal_nbi_warp, types.Function(_typing_putmem_signal_nbi_warp))


@register
class _typing_putmem_signal_nbi_block(ConcreteTemplate):
    key = globals()["putmem_signal_nbi_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(putmem_signal_nbi_block, types.Function(_typing_putmem_signal_nbi_block))


@register
class _typing_put8_signal_nbi_warp(ConcreteTemplate):
    key = globals()["put8_signal_nbi_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put8_signal_nbi_warp, types.Function(_typing_put8_signal_nbi_warp))


@register
class _typing_put6_signal_nbi_warp(ConcreteTemplate):
    key = globals()["put6_signal_nbi_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put6_signal_nbi_warp, types.Function(_typing_put6_signal_nbi_warp))


@register
class _typing_put32_signal_nbi_warp(ConcreteTemplate):
    key = globals()["put32_signal_nbi_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put32_signal_nbi_warp, types.Function(_typing_put32_signal_nbi_warp))


@register
class _typing_put64_signal_nbi_warp(ConcreteTemplate):
    key = globals()["put64_signal_nbi_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put64_signal_nbi_warp, types.Function(_typing_put64_signal_nbi_warp))


@register
class _typing_put128_signal_nbi_warp(ConcreteTemplate):
    key = globals()["put128_signal_nbi_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put128_signal_nbi_warp, types.Function(_typing_put128_signal_nbi_warp))


@register
class _typing_put8_signal_nbi_block(ConcreteTemplate):
    key = globals()["put8_signal_nbi_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put8_signal_nbi_block, types.Function(_typing_put8_signal_nbi_block))


@register
class _typing_put6_signal_nbi_block(ConcreteTemplate):
    key = globals()["put6_signal_nbi_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put6_signal_nbi_block, types.Function(_typing_put6_signal_nbi_block))


@register
class _typing_put32_signal_nbi_block(ConcreteTemplate):
    key = globals()["put32_signal_nbi_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put32_signal_nbi_block, types.Function(_typing_put32_signal_nbi_block))


@register
class _typing_put64_signal_nbi_block(ConcreteTemplate):
    key = globals()["put64_signal_nbi_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put64_signal_nbi_block, types.Function(_typing_put64_signal_nbi_block))


@register
class _typing_put128_signal_nbi_block(ConcreteTemplate):
    key = globals()["put128_signal_nbi_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, CPointer(uint64), uint64, int32, int32)]

register_global(put128_signal_nbi_block, types.Function(_typing_put128_signal_nbi_block))


@register
class _typing_bfloat16_get_warp(ConcreteTemplate):
    key = globals()["bfloat16_get_warp"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)]

register_global(bfloat16_get_warp, types.Function(_typing_bfloat16_get_warp))


@register
class _typing_bfloat16_get_block(ConcreteTemplate):
    key = globals()["bfloat16_get_block"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)]

register_global(bfloat16_get_block, types.Function(_typing_bfloat16_get_block))


@register
class _typing_half_get_warp(ConcreteTemplate):
    key = globals()["half_get_warp"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32)]

register_global(half_get_warp, types.Function(_typing_half_get_warp))


@register
class _typing_half_get_block(ConcreteTemplate):
    key = globals()["half_get_block"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32)]

register_global(half_get_block, types.Function(_typing_half_get_block))


@register
class _typing_float_get_warp(ConcreteTemplate):
    key = globals()["float_get_warp"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32)]

register_global(float_get_warp, types.Function(_typing_float_get_warp))


@register
class _typing_float_get_block(ConcreteTemplate):
    key = globals()["float_get_block"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32)]

register_global(float_get_block, types.Function(_typing_float_get_block))


@register
class _typing_double_get_warp(ConcreteTemplate):
    key = globals()["double_get_warp"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32)]

register_global(double_get_warp, types.Function(_typing_double_get_warp))


@register
class _typing_double_get_block(ConcreteTemplate):
    key = globals()["double_get_block"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32)]

register_global(double_get_block, types.Function(_typing_double_get_block))


@register
class _typing_char_get_warp(ConcreteTemplate):
    key = globals()["char_get_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(char_get_warp, types.Function(_typing_char_get_warp))


@register
class _typing_char_get_block(ConcreteTemplate):
    key = globals()["char_get_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(char_get_block, types.Function(_typing_char_get_block))


@register
class _typing_short_get_warp(ConcreteTemplate):
    key = globals()["short_get_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(short_get_warp, types.Function(_typing_short_get_warp))


@register
class _typing_short_get_block(ConcreteTemplate):
    key = globals()["short_get_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(short_get_block, types.Function(_typing_short_get_block))


@register
class _typing_schar_get_warp(ConcreteTemplate):
    key = globals()["schar_get_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(schar_get_warp, types.Function(_typing_schar_get_warp))


@register
class _typing_schar_get_block(ConcreteTemplate):
    key = globals()["schar_get_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(schar_get_block, types.Function(_typing_schar_get_block))


@register
class _typing_int_get_warp(ConcreteTemplate):
    key = globals()["int_get_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int_get_warp, types.Function(_typing_int_get_warp))


@register
class _typing_int_get_block(ConcreteTemplate):
    key = globals()["int_get_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int_get_block, types.Function(_typing_int_get_block))


@register
class _typing_long_get_warp(ConcreteTemplate):
    key = globals()["long_get_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(long_get_warp, types.Function(_typing_long_get_warp))


@register
class _typing_long_get_block(ConcreteTemplate):
    key = globals()["long_get_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(long_get_block, types.Function(_typing_long_get_block))


@register
class _typing_longlong_get_warp(ConcreteTemplate):
    key = globals()["longlong_get_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(longlong_get_warp, types.Function(_typing_longlong_get_warp))


@register
class _typing_longlong_get_block(ConcreteTemplate):
    key = globals()["longlong_get_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(longlong_get_block, types.Function(_typing_longlong_get_block))


@register
class _typing_uchar_get_warp(ConcreteTemplate):
    key = globals()["uchar_get_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uchar_get_warp, types.Function(_typing_uchar_get_warp))


@register
class _typing_uchar_get_block(ConcreteTemplate):
    key = globals()["uchar_get_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uchar_get_block, types.Function(_typing_uchar_get_block))


@register
class _typing_ushort_get_warp(ConcreteTemplate):
    key = globals()["ushort_get_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(ushort_get_warp, types.Function(_typing_ushort_get_warp))


@register
class _typing_ushort_get_block(ConcreteTemplate):
    key = globals()["ushort_get_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(ushort_get_block, types.Function(_typing_ushort_get_block))


@register
class _typing_uint_get_warp(ConcreteTemplate):
    key = globals()["uint_get_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint_get_warp, types.Function(_typing_uint_get_warp))


@register
class _typing_uint_get_block(ConcreteTemplate):
    key = globals()["uint_get_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint_get_block, types.Function(_typing_uint_get_block))


@register
class _typing_ulong_get_warp(ConcreteTemplate):
    key = globals()["ulong_get_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulong_get_warp, types.Function(_typing_ulong_get_warp))


@register
class _typing_ulong_get_block(ConcreteTemplate):
    key = globals()["ulong_get_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulong_get_block, types.Function(_typing_ulong_get_block))


@register
class _typing_ulonglong_get_warp(ConcreteTemplate):
    key = globals()["ulonglong_get_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulonglong_get_warp, types.Function(_typing_ulonglong_get_warp))


@register
class _typing_ulonglong_get_block(ConcreteTemplate):
    key = globals()["ulonglong_get_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulonglong_get_block, types.Function(_typing_ulonglong_get_block))


@register
class _typing_int8_get_warp(ConcreteTemplate):
    key = globals()["int8_get_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(int8_get_warp, types.Function(_typing_int8_get_warp))


@register
class _typing_int8_get_block(ConcreteTemplate):
    key = globals()["int8_get_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(int8_get_block, types.Function(_typing_int8_get_block))


@register
class _typing_int16_get_warp(ConcreteTemplate):
    key = globals()["int16_get_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(int16_get_warp, types.Function(_typing_int16_get_warp))


@register
class _typing_int16_get_block(ConcreteTemplate):
    key = globals()["int16_get_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(int16_get_block, types.Function(_typing_int16_get_block))


@register
class _typing_int32_get_warp(ConcreteTemplate):
    key = globals()["int32_get_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int32_get_warp, types.Function(_typing_int32_get_warp))


@register
class _typing_int32_get_block(ConcreteTemplate):
    key = globals()["int32_get_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int32_get_block, types.Function(_typing_int32_get_block))


@register
class _typing_int64_get_warp(ConcreteTemplate):
    key = globals()["int64_get_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(int64_get_warp, types.Function(_typing_int64_get_warp))


@register
class _typing_int64_get_block(ConcreteTemplate):
    key = globals()["int64_get_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(int64_get_block, types.Function(_typing_int64_get_block))


@register
class _typing_uint8_get_warp(ConcreteTemplate):
    key = globals()["uint8_get_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uint8_get_warp, types.Function(_typing_uint8_get_warp))


@register
class _typing_uint8_get_block(ConcreteTemplate):
    key = globals()["uint8_get_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uint8_get_block, types.Function(_typing_uint8_get_block))


@register
class _typing_uint16_get_warp(ConcreteTemplate):
    key = globals()["uint16_get_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(uint16_get_warp, types.Function(_typing_uint16_get_warp))


@register
class _typing_uint16_get_block(ConcreteTemplate):
    key = globals()["uint16_get_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(uint16_get_block, types.Function(_typing_uint16_get_block))


@register
class _typing_uint32_get_warp(ConcreteTemplate):
    key = globals()["uint32_get_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint32_get_warp, types.Function(_typing_uint32_get_warp))


@register
class _typing_uint32_get_block(ConcreteTemplate):
    key = globals()["uint32_get_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint32_get_block, types.Function(_typing_uint32_get_block))


@register
class _typing_uint64_get_warp(ConcreteTemplate):
    key = globals()["uint64_get_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(uint64_get_warp, types.Function(_typing_uint64_get_warp))


@register
class _typing_uint64_get_block(ConcreteTemplate):
    key = globals()["uint64_get_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(uint64_get_block, types.Function(_typing_uint64_get_block))


@register
class _typing_size_get_warp(ConcreteTemplate):
    key = globals()["size_get_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(size_get_warp, types.Function(_typing_size_get_warp))


@register
class _typing_size_get_block(ConcreteTemplate):
    key = globals()["size_get_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(size_get_block, types.Function(_typing_size_get_block))


@register
class _typing_ptrdiff_get_warp(ConcreteTemplate):
    key = globals()["ptrdiff_get_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(ptrdiff_get_warp, types.Function(_typing_ptrdiff_get_warp))


@register
class _typing_ptrdiff_get_block(ConcreteTemplate):
    key = globals()["ptrdiff_get_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(ptrdiff_get_block, types.Function(_typing_ptrdiff_get_block))


@register
class _typing_put8_warp(ConcreteTemplate):
    key = globals()["put8_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put8_warp, types.Function(_typing_put8_warp))


@register
class _typing_put8_block(ConcreteTemplate):
    key = globals()["put8_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put8_block, types.Function(_typing_put8_block))


@register
class _typing_put16_warp(ConcreteTemplate):
    key = globals()["put16_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put16_warp, types.Function(_typing_put16_warp))


@register
class _typing_put16_block(ConcreteTemplate):
    key = globals()["put16_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put16_block, types.Function(_typing_put16_block))


@register
class _typing_put32_warp(ConcreteTemplate):
    key = globals()["put32_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put32_warp, types.Function(_typing_put32_warp))


@register
class _typing_put32_block(ConcreteTemplate):
    key = globals()["put32_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put32_block, types.Function(_typing_put32_block))


@register
class _typing_put64_warp(ConcreteTemplate):
    key = globals()["put64_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put64_warp, types.Function(_typing_put64_warp))


@register
class _typing_put64_block(ConcreteTemplate):
    key = globals()["put64_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put64_block, types.Function(_typing_put64_block))


@register
class _typing_put128_warp(ConcreteTemplate):
    key = globals()["put128_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put128_warp, types.Function(_typing_put128_warp))


@register
class _typing_put128_block(ConcreteTemplate):
    key = globals()["put128_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put128_block, types.Function(_typing_put128_block))


@register
class _typing_get8_warp(ConcreteTemplate):
    key = globals()["get8_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get8_warp, types.Function(_typing_get8_warp))


@register
class _typing_get8_block(ConcreteTemplate):
    key = globals()["get8_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get8_block, types.Function(_typing_get8_block))


@register
class _typing_get16_warp(ConcreteTemplate):
    key = globals()["get16_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get16_warp, types.Function(_typing_get16_warp))


@register
class _typing_get16_block(ConcreteTemplate):
    key = globals()["get16_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get16_block, types.Function(_typing_get16_block))


@register
class _typing_get32_warp(ConcreteTemplate):
    key = globals()["get32_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get32_warp, types.Function(_typing_get32_warp))


@register
class _typing_get32_block(ConcreteTemplate):
    key = globals()["get32_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get32_block, types.Function(_typing_get32_block))


@register
class _typing_get64_warp(ConcreteTemplate):
    key = globals()["get64_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get64_warp, types.Function(_typing_get64_warp))


@register
class _typing_get64_block(ConcreteTemplate):
    key = globals()["get64_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get64_block, types.Function(_typing_get64_block))


@register
class _typing_get128_warp(ConcreteTemplate):
    key = globals()["get128_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get128_warp, types.Function(_typing_get128_warp))


@register
class _typing_get128_block(ConcreteTemplate):
    key = globals()["get128_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get128_block, types.Function(_typing_get128_block))


@register
class _typing_putmem_warp(ConcreteTemplate):
    key = globals()["putmem_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(putmem_warp, types.Function(_typing_putmem_warp))


@register
class _typing_putmem_block(ConcreteTemplate):
    key = globals()["putmem_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(putmem_block, types.Function(_typing_putmem_block))


@register
class _typing_getmem_warp(ConcreteTemplate):
    key = globals()["getmem_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(getmem_warp, types.Function(_typing_getmem_warp))


@register
class _typing_getmem_block(ConcreteTemplate):
    key = globals()["getmem_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(getmem_block, types.Function(_typing_getmem_block))


@register
class _typing_bfloat16_put_nbi_warp(ConcreteTemplate):
    key = globals()["bfloat16_put_nbi_warp"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)]

register_global(bfloat16_put_nbi_warp, types.Function(_typing_bfloat16_put_nbi_warp))


@register
class _typing_bfloat16_put_nbi_block(ConcreteTemplate):
    key = globals()["bfloat16_put_nbi_block"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)]

register_global(bfloat16_put_nbi_block, types.Function(_typing_bfloat16_put_nbi_block))


@register
class _typing_half_put_nbi_warp(ConcreteTemplate):
    key = globals()["half_put_nbi_warp"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32)]

register_global(half_put_nbi_warp, types.Function(_typing_half_put_nbi_warp))


@register
class _typing_half_put_nbi_block(ConcreteTemplate):
    key = globals()["half_put_nbi_block"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32)]

register_global(half_put_nbi_block, types.Function(_typing_half_put_nbi_block))


@register
class _typing_float_put_nbi_warp(ConcreteTemplate):
    key = globals()["float_put_nbi_warp"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32)]

register_global(float_put_nbi_warp, types.Function(_typing_float_put_nbi_warp))


@register
class _typing_float_put_nbi_block(ConcreteTemplate):
    key = globals()["float_put_nbi_block"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32)]

register_global(float_put_nbi_block, types.Function(_typing_float_put_nbi_block))


@register
class _typing_double_put_nbi_warp(ConcreteTemplate):
    key = globals()["double_put_nbi_warp"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32)]

register_global(double_put_nbi_warp, types.Function(_typing_double_put_nbi_warp))


@register
class _typing_double_put_nbi_block(ConcreteTemplate):
    key = globals()["double_put_nbi_block"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32)]

register_global(double_put_nbi_block, types.Function(_typing_double_put_nbi_block))


@register
class _typing_char_put_nbi_warp(ConcreteTemplate):
    key = globals()["char_put_nbi_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(char_put_nbi_warp, types.Function(_typing_char_put_nbi_warp))


@register
class _typing_char_put_nbi_block(ConcreteTemplate):
    key = globals()["char_put_nbi_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(char_put_nbi_block, types.Function(_typing_char_put_nbi_block))


@register
class _typing_short_put_nbi_warp(ConcreteTemplate):
    key = globals()["short_put_nbi_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(short_put_nbi_warp, types.Function(_typing_short_put_nbi_warp))


@register
class _typing_short_put_nbi_block(ConcreteTemplate):
    key = globals()["short_put_nbi_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(short_put_nbi_block, types.Function(_typing_short_put_nbi_block))


@register
class _typing_schar_put_nbi_warp(ConcreteTemplate):
    key = globals()["schar_put_nbi_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(schar_put_nbi_warp, types.Function(_typing_schar_put_nbi_warp))


@register
class _typing_schar_put_nbi_block(ConcreteTemplate):
    key = globals()["schar_put_nbi_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(schar_put_nbi_block, types.Function(_typing_schar_put_nbi_block))


@register
class _typing_int_put_nbi_warp(ConcreteTemplate):
    key = globals()["int_put_nbi_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int_put_nbi_warp, types.Function(_typing_int_put_nbi_warp))


@register
class _typing_int_put_nbi_block(ConcreteTemplate):
    key = globals()["int_put_nbi_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int_put_nbi_block, types.Function(_typing_int_put_nbi_block))


@register
class _typing_long_put_nbi_warp(ConcreteTemplate):
    key = globals()["long_put_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(long_put_nbi_warp, types.Function(_typing_long_put_nbi_warp))


@register
class _typing_long_put_nbi_block(ConcreteTemplate):
    key = globals()["long_put_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(long_put_nbi_block, types.Function(_typing_long_put_nbi_block))


@register
class _typing_longlong_put_nbi_warp(ConcreteTemplate):
    key = globals()["longlong_put_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(longlong_put_nbi_warp, types.Function(_typing_longlong_put_nbi_warp))


@register
class _typing_longlong_put_nbi_block(ConcreteTemplate):
    key = globals()["longlong_put_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(longlong_put_nbi_block, types.Function(_typing_longlong_put_nbi_block))


@register
class _typing_uchar_put_nbi_warp(ConcreteTemplate):
    key = globals()["uchar_put_nbi_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uchar_put_nbi_warp, types.Function(_typing_uchar_put_nbi_warp))


@register
class _typing_uchar_put_nbi_block(ConcreteTemplate):
    key = globals()["uchar_put_nbi_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uchar_put_nbi_block, types.Function(_typing_uchar_put_nbi_block))


@register
class _typing_ushort_put_nbi_warp(ConcreteTemplate):
    key = globals()["ushort_put_nbi_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(ushort_put_nbi_warp, types.Function(_typing_ushort_put_nbi_warp))


@register
class _typing_ushort_put_nbi_block(ConcreteTemplate):
    key = globals()["ushort_put_nbi_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(ushort_put_nbi_block, types.Function(_typing_ushort_put_nbi_block))


@register
class _typing_uint_put_nbi_warp(ConcreteTemplate):
    key = globals()["uint_put_nbi_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint_put_nbi_warp, types.Function(_typing_uint_put_nbi_warp))


@register
class _typing_uint_put_nbi_block(ConcreteTemplate):
    key = globals()["uint_put_nbi_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint_put_nbi_block, types.Function(_typing_uint_put_nbi_block))


@register
class _typing_ulong_put_nbi_warp(ConcreteTemplate):
    key = globals()["ulong_put_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulong_put_nbi_warp, types.Function(_typing_ulong_put_nbi_warp))


@register
class _typing_ulong_put_nbi_block(ConcreteTemplate):
    key = globals()["ulong_put_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulong_put_nbi_block, types.Function(_typing_ulong_put_nbi_block))


@register
class _typing_ulonglong_put_nbi_warp(ConcreteTemplate):
    key = globals()["ulonglong_put_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulonglong_put_nbi_warp, types.Function(_typing_ulonglong_put_nbi_warp))


@register
class _typing_ulonglong_put_nbi_block(ConcreteTemplate):
    key = globals()["ulonglong_put_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulonglong_put_nbi_block, types.Function(_typing_ulonglong_put_nbi_block))


@register
class _typing_int8_put_nbi_warp(ConcreteTemplate):
    key = globals()["int8_put_nbi_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(int8_put_nbi_warp, types.Function(_typing_int8_put_nbi_warp))


@register
class _typing_int8_put_nbi_block(ConcreteTemplate):
    key = globals()["int8_put_nbi_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(int8_put_nbi_block, types.Function(_typing_int8_put_nbi_block))


@register
class _typing_int16_put_nbi_warp(ConcreteTemplate):
    key = globals()["int16_put_nbi_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(int16_put_nbi_warp, types.Function(_typing_int16_put_nbi_warp))


@register
class _typing_int16_put_nbi_block(ConcreteTemplate):
    key = globals()["int16_put_nbi_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(int16_put_nbi_block, types.Function(_typing_int16_put_nbi_block))


@register
class _typing_int32_put_nbi_warp(ConcreteTemplate):
    key = globals()["int32_put_nbi_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int32_put_nbi_warp, types.Function(_typing_int32_put_nbi_warp))


@register
class _typing_int32_put_nbi_block(ConcreteTemplate):
    key = globals()["int32_put_nbi_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int32_put_nbi_block, types.Function(_typing_int32_put_nbi_block))


@register
class _typing_int64_put_nbi_warp(ConcreteTemplate):
    key = globals()["int64_put_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(int64_put_nbi_warp, types.Function(_typing_int64_put_nbi_warp))


@register
class _typing_int64_put_nbi_block(ConcreteTemplate):
    key = globals()["int64_put_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(int64_put_nbi_block, types.Function(_typing_int64_put_nbi_block))


@register
class _typing_uint8_put_nbi_warp(ConcreteTemplate):
    key = globals()["uint8_put_nbi_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uint8_put_nbi_warp, types.Function(_typing_uint8_put_nbi_warp))


@register
class _typing_uint8_put_nbi_block(ConcreteTemplate):
    key = globals()["uint8_put_nbi_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uint8_put_nbi_block, types.Function(_typing_uint8_put_nbi_block))


@register
class _typing_uint16_put_nbi_warp(ConcreteTemplate):
    key = globals()["uint16_put_nbi_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(uint16_put_nbi_warp, types.Function(_typing_uint16_put_nbi_warp))


@register
class _typing_uint16_put_nbi_block(ConcreteTemplate):
    key = globals()["uint16_put_nbi_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(uint16_put_nbi_block, types.Function(_typing_uint16_put_nbi_block))


@register
class _typing_uint32_put_nbi_warp(ConcreteTemplate):
    key = globals()["uint32_put_nbi_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint32_put_nbi_warp, types.Function(_typing_uint32_put_nbi_warp))


@register
class _typing_uint32_put_nbi_block(ConcreteTemplate):
    key = globals()["uint32_put_nbi_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint32_put_nbi_block, types.Function(_typing_uint32_put_nbi_block))


@register
class _typing_uint64_put_nbi_warp(ConcreteTemplate):
    key = globals()["uint64_put_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(uint64_put_nbi_warp, types.Function(_typing_uint64_put_nbi_warp))


@register
class _typing_uint64_put_nbi_block(ConcreteTemplate):
    key = globals()["uint64_put_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(uint64_put_nbi_block, types.Function(_typing_uint64_put_nbi_block))


@register
class _typing_size_put_nbi_warp(ConcreteTemplate):
    key = globals()["size_put_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(size_put_nbi_warp, types.Function(_typing_size_put_nbi_warp))


@register
class _typing_size_put_nbi_block(ConcreteTemplate):
    key = globals()["size_put_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(size_put_nbi_block, types.Function(_typing_size_put_nbi_block))


@register
class _typing_ptrdiff_put_nbi_warp(ConcreteTemplate):
    key = globals()["ptrdiff_put_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(ptrdiff_put_nbi_warp, types.Function(_typing_ptrdiff_put_nbi_warp))


@register
class _typing_ptrdiff_put_nbi_block(ConcreteTemplate):
    key = globals()["ptrdiff_put_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(ptrdiff_put_nbi_block, types.Function(_typing_ptrdiff_put_nbi_block))


@register
class _typing_bfloat16_get_nbi_warp(ConcreteTemplate):
    key = globals()["bfloat16_get_nbi_warp"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)]

register_global(bfloat16_get_nbi_warp, types.Function(_typing_bfloat16_get_nbi_warp))


@register
class _typing_bfloat16_get_nbi_block(ConcreteTemplate):
    key = globals()["bfloat16_get_nbi_block"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)]

register_global(bfloat16_get_nbi_block, types.Function(_typing_bfloat16_get_nbi_block))


@register
class _typing_half_get_nbi_warp(ConcreteTemplate):
    key = globals()["half_get_nbi_warp"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32)]

register_global(half_get_nbi_warp, types.Function(_typing_half_get_nbi_warp))


@register
class _typing_half_get_nbi_block(ConcreteTemplate):
    key = globals()["half_get_nbi_block"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32)]

register_global(half_get_nbi_block, types.Function(_typing_half_get_nbi_block))


@register
class _typing_float_get_nbi_warp(ConcreteTemplate):
    key = globals()["float_get_nbi_warp"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32)]

register_global(float_get_nbi_warp, types.Function(_typing_float_get_nbi_warp))


@register
class _typing_float_get_nbi_block(ConcreteTemplate):
    key = globals()["float_get_nbi_block"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32)]

register_global(float_get_nbi_block, types.Function(_typing_float_get_nbi_block))


@register
class _typing_double_get_nbi_warp(ConcreteTemplate):
    key = globals()["double_get_nbi_warp"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32)]

register_global(double_get_nbi_warp, types.Function(_typing_double_get_nbi_warp))


@register
class _typing_double_get_nbi_block(ConcreteTemplate):
    key = globals()["double_get_nbi_block"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32)]

register_global(double_get_nbi_block, types.Function(_typing_double_get_nbi_block))


@register
class _typing_char_get_nbi_warp(ConcreteTemplate):
    key = globals()["char_get_nbi_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(char_get_nbi_warp, types.Function(_typing_char_get_nbi_warp))


@register
class _typing_char_get_nbi_block(ConcreteTemplate):
    key = globals()["char_get_nbi_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(char_get_nbi_block, types.Function(_typing_char_get_nbi_block))


@register
class _typing_short_get_nbi_warp(ConcreteTemplate):
    key = globals()["short_get_nbi_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(short_get_nbi_warp, types.Function(_typing_short_get_nbi_warp))


@register
class _typing_short_get_nbi_block(ConcreteTemplate):
    key = globals()["short_get_nbi_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(short_get_nbi_block, types.Function(_typing_short_get_nbi_block))


@register
class _typing_schar_get_nbi_warp(ConcreteTemplate):
    key = globals()["schar_get_nbi_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(schar_get_nbi_warp, types.Function(_typing_schar_get_nbi_warp))


@register
class _typing_schar_get_nbi_block(ConcreteTemplate):
    key = globals()["schar_get_nbi_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(schar_get_nbi_block, types.Function(_typing_schar_get_nbi_block))


@register
class _typing_int_get_nbi_warp(ConcreteTemplate):
    key = globals()["int_get_nbi_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int_get_nbi_warp, types.Function(_typing_int_get_nbi_warp))


@register
class _typing_int_get_nbi_block(ConcreteTemplate):
    key = globals()["int_get_nbi_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int_get_nbi_block, types.Function(_typing_int_get_nbi_block))


@register
class _typing_long_get_nbi_warp(ConcreteTemplate):
    key = globals()["long_get_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(long_get_nbi_warp, types.Function(_typing_long_get_nbi_warp))


@register
class _typing_long_get_nbi_block(ConcreteTemplate):
    key = globals()["long_get_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(long_get_nbi_block, types.Function(_typing_long_get_nbi_block))


@register
class _typing_longlong_get_nbi_warp(ConcreteTemplate):
    key = globals()["longlong_get_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(longlong_get_nbi_warp, types.Function(_typing_longlong_get_nbi_warp))


@register
class _typing_longlong_get_nbi_block(ConcreteTemplate):
    key = globals()["longlong_get_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(longlong_get_nbi_block, types.Function(_typing_longlong_get_nbi_block))


@register
class _typing_uchar_get_nbi_warp(ConcreteTemplate):
    key = globals()["uchar_get_nbi_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uchar_get_nbi_warp, types.Function(_typing_uchar_get_nbi_warp))


@register
class _typing_uchar_get_nbi_block(ConcreteTemplate):
    key = globals()["uchar_get_nbi_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uchar_get_nbi_block, types.Function(_typing_uchar_get_nbi_block))


@register
class _typing_ushort_get_nbi_warp(ConcreteTemplate):
    key = globals()["ushort_get_nbi_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(ushort_get_nbi_warp, types.Function(_typing_ushort_get_nbi_warp))


@register
class _typing_ushort_get_nbi_block(ConcreteTemplate):
    key = globals()["ushort_get_nbi_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(ushort_get_nbi_block, types.Function(_typing_ushort_get_nbi_block))


@register
class _typing_uint_get_nbi_warp(ConcreteTemplate):
    key = globals()["uint_get_nbi_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint_get_nbi_warp, types.Function(_typing_uint_get_nbi_warp))


@register
class _typing_uint_get_nbi_block(ConcreteTemplate):
    key = globals()["uint_get_nbi_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint_get_nbi_block, types.Function(_typing_uint_get_nbi_block))


@register
class _typing_ulong_get_nbi_warp(ConcreteTemplate):
    key = globals()["ulong_get_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulong_get_nbi_warp, types.Function(_typing_ulong_get_nbi_warp))


@register
class _typing_ulong_get_nbi_block(ConcreteTemplate):
    key = globals()["ulong_get_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulong_get_nbi_block, types.Function(_typing_ulong_get_nbi_block))


@register
class _typing_ulonglong_get_nbi_warp(ConcreteTemplate):
    key = globals()["ulonglong_get_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulonglong_get_nbi_warp, types.Function(_typing_ulonglong_get_nbi_warp))


@register
class _typing_ulonglong_get_nbi_block(ConcreteTemplate):
    key = globals()["ulonglong_get_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulonglong_get_nbi_block, types.Function(_typing_ulonglong_get_nbi_block))


@register
class _typing_int8_get_nbi_warp(ConcreteTemplate):
    key = globals()["int8_get_nbi_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(int8_get_nbi_warp, types.Function(_typing_int8_get_nbi_warp))


@register
class _typing_int8_get_nbi_block(ConcreteTemplate):
    key = globals()["int8_get_nbi_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(int8_get_nbi_block, types.Function(_typing_int8_get_nbi_block))


@register
class _typing_int16_get_nbi_warp(ConcreteTemplate):
    key = globals()["int16_get_nbi_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(int16_get_nbi_warp, types.Function(_typing_int16_get_nbi_warp))


@register
class _typing_int16_get_nbi_block(ConcreteTemplate):
    key = globals()["int16_get_nbi_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(int16_get_nbi_block, types.Function(_typing_int16_get_nbi_block))


@register
class _typing_int32_get_nbi_warp(ConcreteTemplate):
    key = globals()["int32_get_nbi_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int32_get_nbi_warp, types.Function(_typing_int32_get_nbi_warp))


@register
class _typing_int32_get_nbi_block(ConcreteTemplate):
    key = globals()["int32_get_nbi_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int32_get_nbi_block, types.Function(_typing_int32_get_nbi_block))


@register
class _typing_int64_get_nbi_warp(ConcreteTemplate):
    key = globals()["int64_get_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(int64_get_nbi_warp, types.Function(_typing_int64_get_nbi_warp))


@register
class _typing_int64_get_nbi_block(ConcreteTemplate):
    key = globals()["int64_get_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(int64_get_nbi_block, types.Function(_typing_int64_get_nbi_block))


@register
class _typing_uint8_get_nbi_warp(ConcreteTemplate):
    key = globals()["uint8_get_nbi_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uint8_get_nbi_warp, types.Function(_typing_uint8_get_nbi_warp))


@register
class _typing_uint8_get_nbi_block(ConcreteTemplate):
    key = globals()["uint8_get_nbi_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uint8_get_nbi_block, types.Function(_typing_uint8_get_nbi_block))


@register
class _typing_uint16_get_nbi_warp(ConcreteTemplate):
    key = globals()["uint16_get_nbi_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(uint16_get_nbi_warp, types.Function(_typing_uint16_get_nbi_warp))


@register
class _typing_uint16_get_nbi_block(ConcreteTemplate):
    key = globals()["uint16_get_nbi_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(uint16_get_nbi_block, types.Function(_typing_uint16_get_nbi_block))


@register
class _typing_uint32_get_nbi_warp(ConcreteTemplate):
    key = globals()["uint32_get_nbi_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint32_get_nbi_warp, types.Function(_typing_uint32_get_nbi_warp))


@register
class _typing_uint32_get_nbi_block(ConcreteTemplate):
    key = globals()["uint32_get_nbi_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint32_get_nbi_block, types.Function(_typing_uint32_get_nbi_block))


@register
class _typing_uint64_get_nbi_warp(ConcreteTemplate):
    key = globals()["uint64_get_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(uint64_get_nbi_warp, types.Function(_typing_uint64_get_nbi_warp))


@register
class _typing_uint64_get_nbi_block(ConcreteTemplate):
    key = globals()["uint64_get_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(uint64_get_nbi_block, types.Function(_typing_uint64_get_nbi_block))


@register
class _typing_size_get_nbi_warp(ConcreteTemplate):
    key = globals()["size_get_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(size_get_nbi_warp, types.Function(_typing_size_get_nbi_warp))


@register
class _typing_size_get_nbi_block(ConcreteTemplate):
    key = globals()["size_get_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(size_get_nbi_block, types.Function(_typing_size_get_nbi_block))


@register
class _typing_ptrdiff_get_nbi_warp(ConcreteTemplate):
    key = globals()["ptrdiff_get_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(ptrdiff_get_nbi_warp, types.Function(_typing_ptrdiff_get_nbi_warp))


@register
class _typing_ptrdiff_get_nbi_block(ConcreteTemplate):
    key = globals()["ptrdiff_get_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(ptrdiff_get_nbi_block, types.Function(_typing_ptrdiff_get_nbi_block))


@register
class _typing_put8_nbi_warp(ConcreteTemplate):
    key = globals()["put8_nbi_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put8_nbi_warp, types.Function(_typing_put8_nbi_warp))


@register
class _typing_put8_nbi_block(ConcreteTemplate):
    key = globals()["put8_nbi_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put8_nbi_block, types.Function(_typing_put8_nbi_block))


@register
class _typing_put16_nbi_warp(ConcreteTemplate):
    key = globals()["put16_nbi_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put16_nbi_warp, types.Function(_typing_put16_nbi_warp))


@register
class _typing_put16_nbi_block(ConcreteTemplate):
    key = globals()["put16_nbi_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put16_nbi_block, types.Function(_typing_put16_nbi_block))


@register
class _typing_put32_nbi_warp(ConcreteTemplate):
    key = globals()["put32_nbi_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put32_nbi_warp, types.Function(_typing_put32_nbi_warp))


@register
class _typing_put32_nbi_block(ConcreteTemplate):
    key = globals()["put32_nbi_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put32_nbi_block, types.Function(_typing_put32_nbi_block))


@register
class _typing_put64_nbi_warp(ConcreteTemplate):
    key = globals()["put64_nbi_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put64_nbi_warp, types.Function(_typing_put64_nbi_warp))


@register
class _typing_put64_nbi_block(ConcreteTemplate):
    key = globals()["put64_nbi_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put64_nbi_block, types.Function(_typing_put64_nbi_block))


@register
class _typing_put128_nbi_warp(ConcreteTemplate):
    key = globals()["put128_nbi_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put128_nbi_warp, types.Function(_typing_put128_nbi_warp))


@register
class _typing_put128_nbi_block(ConcreteTemplate):
    key = globals()["put128_nbi_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(put128_nbi_block, types.Function(_typing_put128_nbi_block))


@register
class _typing_get8_nbi_warp(ConcreteTemplate):
    key = globals()["get8_nbi_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get8_nbi_warp, types.Function(_typing_get8_nbi_warp))


@register
class _typing_get8_nbi_block(ConcreteTemplate):
    key = globals()["get8_nbi_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get8_nbi_block, types.Function(_typing_get8_nbi_block))


@register
class _typing_get16_nbi_warp(ConcreteTemplate):
    key = globals()["get16_nbi_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get16_nbi_warp, types.Function(_typing_get16_nbi_warp))


@register
class _typing_get16_nbi_block(ConcreteTemplate):
    key = globals()["get16_nbi_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get16_nbi_block, types.Function(_typing_get16_nbi_block))


@register
class _typing_get32_nbi_warp(ConcreteTemplate):
    key = globals()["get32_nbi_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get32_nbi_warp, types.Function(_typing_get32_nbi_warp))


@register
class _typing_get32_nbi_block(ConcreteTemplate):
    key = globals()["get32_nbi_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get32_nbi_block, types.Function(_typing_get32_nbi_block))


@register
class _typing_get64_nbi_warp(ConcreteTemplate):
    key = globals()["get64_nbi_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get64_nbi_warp, types.Function(_typing_get64_nbi_warp))


@register
class _typing_get64_nbi_block(ConcreteTemplate):
    key = globals()["get64_nbi_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get64_nbi_block, types.Function(_typing_get64_nbi_block))


@register
class _typing_get128_nbi_warp(ConcreteTemplate):
    key = globals()["get128_nbi_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get128_nbi_warp, types.Function(_typing_get128_nbi_warp))


@register
class _typing_get128_nbi_block(ConcreteTemplate):
    key = globals()["get128_nbi_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(get128_nbi_block, types.Function(_typing_get128_nbi_block))


@register
class _typing_putmem_nbi_warp(ConcreteTemplate):
    key = globals()["putmem_nbi_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(putmem_nbi_warp, types.Function(_typing_putmem_nbi_warp))


@register
class _typing_putmem_nbi_block(ConcreteTemplate):
    key = globals()["putmem_nbi_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(putmem_nbi_block, types.Function(_typing_putmem_nbi_block))


@register
class _typing_getmem_nbi_warp(ConcreteTemplate):
    key = globals()["getmem_nbi_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(getmem_nbi_warp, types.Function(_typing_getmem_nbi_warp))


@register
class _typing_getmem_nbi_block(ConcreteTemplate):
    key = globals()["getmem_nbi_block"]
    cases = [signature(void, CPointer(void), CPointer(void), uint64, int32)]

register_global(getmem_nbi_block, types.Function(_typing_getmem_nbi_block))


@register
class _typing_bfloat16_iput_warp(ConcreteTemplate):
    key = globals()["bfloat16_iput_warp"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), int64, int64, uint64, int32)]

register_global(bfloat16_iput_warp, types.Function(_typing_bfloat16_iput_warp))


@register
class _typing_bfloat16_iput_block(ConcreteTemplate):
    key = globals()["bfloat16_iput_block"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), int64, int64, uint64, int32)]

register_global(bfloat16_iput_block, types.Function(_typing_bfloat16_iput_block))


@register
class _typing_half_iput_warp(ConcreteTemplate):
    key = globals()["half_iput_warp"]
    cases = [signature(void, CPointer(float16), CPointer(float16), int64, int64, uint64, int32)]

register_global(half_iput_warp, types.Function(_typing_half_iput_warp))


@register
class _typing_half_iput_block(ConcreteTemplate):
    key = globals()["half_iput_block"]
    cases = [signature(void, CPointer(float16), CPointer(float16), int64, int64, uint64, int32)]

register_global(half_iput_block, types.Function(_typing_half_iput_block))


@register
class _typing_float_iput_warp(ConcreteTemplate):
    key = globals()["float_iput_warp"]
    cases = [signature(void, CPointer(float32), CPointer(float32), int64, int64, uint64, int32)]

register_global(float_iput_warp, types.Function(_typing_float_iput_warp))


@register
class _typing_float_iput_block(ConcreteTemplate):
    key = globals()["float_iput_block"]
    cases = [signature(void, CPointer(float32), CPointer(float32), int64, int64, uint64, int32)]

register_global(float_iput_block, types.Function(_typing_float_iput_block))


@register
class _typing_double_iput_warp(ConcreteTemplate):
    key = globals()["double_iput_warp"]
    cases = [signature(void, CPointer(float64), CPointer(float64), int64, int64, uint64, int32)]

register_global(double_iput_warp, types.Function(_typing_double_iput_warp))


@register
class _typing_double_iput_block(ConcreteTemplate):
    key = globals()["double_iput_block"]
    cases = [signature(void, CPointer(float64), CPointer(float64), int64, int64, uint64, int32)]

register_global(double_iput_block, types.Function(_typing_double_iput_block))


@register
class _typing_char_iput_warp(ConcreteTemplate):
    key = globals()["char_iput_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)]

register_global(char_iput_warp, types.Function(_typing_char_iput_warp))


@register
class _typing_char_iput_block(ConcreteTemplate):
    key = globals()["char_iput_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)]

register_global(char_iput_block, types.Function(_typing_char_iput_block))


@register
class _typing_short_iput_warp(ConcreteTemplate):
    key = globals()["short_iput_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)]

register_global(short_iput_warp, types.Function(_typing_short_iput_warp))


@register
class _typing_short_iput_block(ConcreteTemplate):
    key = globals()["short_iput_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)]

register_global(short_iput_block, types.Function(_typing_short_iput_block))


@register
class _typing_schar_iput_warp(ConcreteTemplate):
    key = globals()["schar_iput_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)]

register_global(schar_iput_warp, types.Function(_typing_schar_iput_warp))


@register
class _typing_schar_iput_block(ConcreteTemplate):
    key = globals()["schar_iput_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)]

register_global(schar_iput_block, types.Function(_typing_schar_iput_block))


@register
class _typing_int_iput_warp(ConcreteTemplate):
    key = globals()["int_iput_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)]

register_global(int_iput_warp, types.Function(_typing_int_iput_warp))


@register
class _typing_int_iput_block(ConcreteTemplate):
    key = globals()["int_iput_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)]

register_global(int_iput_block, types.Function(_typing_int_iput_block))


@register
class _typing_long_iput_warp(ConcreteTemplate):
    key = globals()["long_iput_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(long_iput_warp, types.Function(_typing_long_iput_warp))


@register
class _typing_long_iput_block(ConcreteTemplate):
    key = globals()["long_iput_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(long_iput_block, types.Function(_typing_long_iput_block))


@register
class _typing_longlong_iput_warp(ConcreteTemplate):
    key = globals()["longlong_iput_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(longlong_iput_warp, types.Function(_typing_longlong_iput_warp))


@register
class _typing_longlong_iput_block(ConcreteTemplate):
    key = globals()["longlong_iput_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(longlong_iput_block, types.Function(_typing_longlong_iput_block))


@register
class _typing_uchar_iput_warp(ConcreteTemplate):
    key = globals()["uchar_iput_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)]

register_global(uchar_iput_warp, types.Function(_typing_uchar_iput_warp))


@register
class _typing_uchar_iput_block(ConcreteTemplate):
    key = globals()["uchar_iput_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)]

register_global(uchar_iput_block, types.Function(_typing_uchar_iput_block))


@register
class _typing_ushort_iput_warp(ConcreteTemplate):
    key = globals()["ushort_iput_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)]

register_global(ushort_iput_warp, types.Function(_typing_ushort_iput_warp))


@register
class _typing_ushort_iput_block(ConcreteTemplate):
    key = globals()["ushort_iput_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)]

register_global(ushort_iput_block, types.Function(_typing_ushort_iput_block))


@register
class _typing_uint_iput_warp(ConcreteTemplate):
    key = globals()["uint_iput_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)]

register_global(uint_iput_warp, types.Function(_typing_uint_iput_warp))


@register
class _typing_uint_iput_block(ConcreteTemplate):
    key = globals()["uint_iput_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)]

register_global(uint_iput_block, types.Function(_typing_uint_iput_block))


@register
class _typing_ulong_iput_warp(ConcreteTemplate):
    key = globals()["ulong_iput_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(ulong_iput_warp, types.Function(_typing_ulong_iput_warp))


@register
class _typing_ulong_iput_block(ConcreteTemplate):
    key = globals()["ulong_iput_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(ulong_iput_block, types.Function(_typing_ulong_iput_block))


@register
class _typing_ulonglong_iput_warp(ConcreteTemplate):
    key = globals()["ulonglong_iput_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(ulonglong_iput_warp, types.Function(_typing_ulonglong_iput_warp))


@register
class _typing_ulonglong_iput_block(ConcreteTemplate):
    key = globals()["ulonglong_iput_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(ulonglong_iput_block, types.Function(_typing_ulonglong_iput_block))


@register
class _typing_int8_iput_warp(ConcreteTemplate):
    key = globals()["int8_iput_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)]

register_global(int8_iput_warp, types.Function(_typing_int8_iput_warp))


@register
class _typing_int8_iput_block(ConcreteTemplate):
    key = globals()["int8_iput_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)]

register_global(int8_iput_block, types.Function(_typing_int8_iput_block))


@register
class _typing_int16_iput_warp(ConcreteTemplate):
    key = globals()["int16_iput_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)]

register_global(int16_iput_warp, types.Function(_typing_int16_iput_warp))


@register
class _typing_int16_iput_block(ConcreteTemplate):
    key = globals()["int16_iput_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)]

register_global(int16_iput_block, types.Function(_typing_int16_iput_block))


@register
class _typing_int32_iput_warp(ConcreteTemplate):
    key = globals()["int32_iput_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)]

register_global(int32_iput_warp, types.Function(_typing_int32_iput_warp))


@register
class _typing_int32_iput_block(ConcreteTemplate):
    key = globals()["int32_iput_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)]

register_global(int32_iput_block, types.Function(_typing_int32_iput_block))


@register
class _typing_int64_iput_warp(ConcreteTemplate):
    key = globals()["int64_iput_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(int64_iput_warp, types.Function(_typing_int64_iput_warp))


@register
class _typing_int64_iput_block(ConcreteTemplate):
    key = globals()["int64_iput_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(int64_iput_block, types.Function(_typing_int64_iput_block))


@register
class _typing_uint8_iput_warp(ConcreteTemplate):
    key = globals()["uint8_iput_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)]

register_global(uint8_iput_warp, types.Function(_typing_uint8_iput_warp))


@register
class _typing_uint8_iput_block(ConcreteTemplate):
    key = globals()["uint8_iput_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)]

register_global(uint8_iput_block, types.Function(_typing_uint8_iput_block))


@register
class _typing_uint16_iput_warp(ConcreteTemplate):
    key = globals()["uint16_iput_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)]

register_global(uint16_iput_warp, types.Function(_typing_uint16_iput_warp))


@register
class _typing_uint16_iput_block(ConcreteTemplate):
    key = globals()["uint16_iput_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)]

register_global(uint16_iput_block, types.Function(_typing_uint16_iput_block))


@register
class _typing_uint32_iput_warp(ConcreteTemplate):
    key = globals()["uint32_iput_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)]

register_global(uint32_iput_warp, types.Function(_typing_uint32_iput_warp))


@register
class _typing_uint32_iput_block(ConcreteTemplate):
    key = globals()["uint32_iput_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)]

register_global(uint32_iput_block, types.Function(_typing_uint32_iput_block))


@register
class _typing_uint64_iput_warp(ConcreteTemplate):
    key = globals()["uint64_iput_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(uint64_iput_warp, types.Function(_typing_uint64_iput_warp))


@register
class _typing_uint64_iput_block(ConcreteTemplate):
    key = globals()["uint64_iput_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(uint64_iput_block, types.Function(_typing_uint64_iput_block))


@register
class _typing_size_iput_warp(ConcreteTemplate):
    key = globals()["size_iput_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(size_iput_warp, types.Function(_typing_size_iput_warp))


@register
class _typing_size_iput_block(ConcreteTemplate):
    key = globals()["size_iput_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(size_iput_block, types.Function(_typing_size_iput_block))


@register
class _typing_ptrdiff_iput_warp(ConcreteTemplate):
    key = globals()["ptrdiff_iput_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(ptrdiff_iput_warp, types.Function(_typing_ptrdiff_iput_warp))


@register
class _typing_ptrdiff_iput_block(ConcreteTemplate):
    key = globals()["ptrdiff_iput_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(ptrdiff_iput_block, types.Function(_typing_ptrdiff_iput_block))


@register
class _typing_iput8_warp(ConcreteTemplate):
    key = globals()["iput8_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iput8_warp, types.Function(_typing_iput8_warp))


@register
class _typing_iput8_block(ConcreteTemplate):
    key = globals()["iput8_block"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iput8_block, types.Function(_typing_iput8_block))


@register
class _typing_iput16_warp(ConcreteTemplate):
    key = globals()["iput16_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iput16_warp, types.Function(_typing_iput16_warp))


@register
class _typing_iput16_block(ConcreteTemplate):
    key = globals()["iput16_block"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iput16_block, types.Function(_typing_iput16_block))


@register
class _typing_iput32_warp(ConcreteTemplate):
    key = globals()["iput32_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iput32_warp, types.Function(_typing_iput32_warp))


@register
class _typing_iput32_block(ConcreteTemplate):
    key = globals()["iput32_block"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iput32_block, types.Function(_typing_iput32_block))


@register
class _typing_iput64_warp(ConcreteTemplate):
    key = globals()["iput64_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iput64_warp, types.Function(_typing_iput64_warp))


@register
class _typing_iput64_block(ConcreteTemplate):
    key = globals()["iput64_block"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iput64_block, types.Function(_typing_iput64_block))


@register
class _typing_iput128_warp(ConcreteTemplate):
    key = globals()["iput128_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iput128_warp, types.Function(_typing_iput128_warp))


@register
class _typing_iput128_block(ConcreteTemplate):
    key = globals()["iput128_block"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iput128_block, types.Function(_typing_iput128_block))


@register
class _typing_bfloat16_iget_warp(ConcreteTemplate):
    key = globals()["bfloat16_iget_warp"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), int64, int64, uint64, int32)]

register_global(bfloat16_iget_warp, types.Function(_typing_bfloat16_iget_warp))


@register
class _typing_bfloat16_iget_block(ConcreteTemplate):
    key = globals()["bfloat16_iget_block"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), int64, int64, uint64, int32)]

register_global(bfloat16_iget_block, types.Function(_typing_bfloat16_iget_block))


@register
class _typing_half_iget_warp(ConcreteTemplate):
    key = globals()["half_iget_warp"]
    cases = [signature(void, CPointer(float16), CPointer(float16), int64, int64, uint64, int32)]

register_global(half_iget_warp, types.Function(_typing_half_iget_warp))


@register
class _typing_half_iget_block(ConcreteTemplate):
    key = globals()["half_iget_block"]
    cases = [signature(void, CPointer(float16), CPointer(float16), int64, int64, uint64, int32)]

register_global(half_iget_block, types.Function(_typing_half_iget_block))


@register
class _typing_float_iget_warp(ConcreteTemplate):
    key = globals()["float_iget_warp"]
    cases = [signature(void, CPointer(float32), CPointer(float32), int64, int64, uint64, int32)]

register_global(float_iget_warp, types.Function(_typing_float_iget_warp))


@register
class _typing_float_iget_block(ConcreteTemplate):
    key = globals()["float_iget_block"]
    cases = [signature(void, CPointer(float32), CPointer(float32), int64, int64, uint64, int32)]

register_global(float_iget_block, types.Function(_typing_float_iget_block))


@register
class _typing_double_iget_warp(ConcreteTemplate):
    key = globals()["double_iget_warp"]
    cases = [signature(void, CPointer(float64), CPointer(float64), int64, int64, uint64, int32)]

register_global(double_iget_warp, types.Function(_typing_double_iget_warp))


@register
class _typing_double_iget_block(ConcreteTemplate):
    key = globals()["double_iget_block"]
    cases = [signature(void, CPointer(float64), CPointer(float64), int64, int64, uint64, int32)]

register_global(double_iget_block, types.Function(_typing_double_iget_block))


@register
class _typing_char_iget_warp(ConcreteTemplate):
    key = globals()["char_iget_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)]

register_global(char_iget_warp, types.Function(_typing_char_iget_warp))


@register
class _typing_char_iget_block(ConcreteTemplate):
    key = globals()["char_iget_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)]

register_global(char_iget_block, types.Function(_typing_char_iget_block))


@register
class _typing_short_iget_warp(ConcreteTemplate):
    key = globals()["short_iget_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)]

register_global(short_iget_warp, types.Function(_typing_short_iget_warp))


@register
class _typing_short_iget_block(ConcreteTemplate):
    key = globals()["short_iget_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)]

register_global(short_iget_block, types.Function(_typing_short_iget_block))


@register
class _typing_schar_iget_warp(ConcreteTemplate):
    key = globals()["schar_iget_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)]

register_global(schar_iget_warp, types.Function(_typing_schar_iget_warp))


@register
class _typing_schar_iget_block(ConcreteTemplate):
    key = globals()["schar_iget_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)]

register_global(schar_iget_block, types.Function(_typing_schar_iget_block))


@register
class _typing_int_iget_warp(ConcreteTemplate):
    key = globals()["int_iget_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)]

register_global(int_iget_warp, types.Function(_typing_int_iget_warp))


@register
class _typing_int_iget_block(ConcreteTemplate):
    key = globals()["int_iget_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)]

register_global(int_iget_block, types.Function(_typing_int_iget_block))


@register
class _typing_long_iget_warp(ConcreteTemplate):
    key = globals()["long_iget_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(long_iget_warp, types.Function(_typing_long_iget_warp))


@register
class _typing_long_iget_block(ConcreteTemplate):
    key = globals()["long_iget_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(long_iget_block, types.Function(_typing_long_iget_block))


@register
class _typing_longlong_iget_warp(ConcreteTemplate):
    key = globals()["longlong_iget_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(longlong_iget_warp, types.Function(_typing_longlong_iget_warp))


@register
class _typing_longlong_iget_block(ConcreteTemplate):
    key = globals()["longlong_iget_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(longlong_iget_block, types.Function(_typing_longlong_iget_block))


@register
class _typing_uchar_iget_warp(ConcreteTemplate):
    key = globals()["uchar_iget_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)]

register_global(uchar_iget_warp, types.Function(_typing_uchar_iget_warp))


@register
class _typing_uchar_iget_block(ConcreteTemplate):
    key = globals()["uchar_iget_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)]

register_global(uchar_iget_block, types.Function(_typing_uchar_iget_block))


@register
class _typing_ushort_iget_warp(ConcreteTemplate):
    key = globals()["ushort_iget_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)]

register_global(ushort_iget_warp, types.Function(_typing_ushort_iget_warp))


@register
class _typing_ushort_iget_block(ConcreteTemplate):
    key = globals()["ushort_iget_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)]

register_global(ushort_iget_block, types.Function(_typing_ushort_iget_block))


@register
class _typing_uint_iget_warp(ConcreteTemplate):
    key = globals()["uint_iget_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)]

register_global(uint_iget_warp, types.Function(_typing_uint_iget_warp))


@register
class _typing_uint_iget_block(ConcreteTemplate):
    key = globals()["uint_iget_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)]

register_global(uint_iget_block, types.Function(_typing_uint_iget_block))


@register
class _typing_ulong_iget_warp(ConcreteTemplate):
    key = globals()["ulong_iget_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(ulong_iget_warp, types.Function(_typing_ulong_iget_warp))


@register
class _typing_ulong_iget_block(ConcreteTemplate):
    key = globals()["ulong_iget_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(ulong_iget_block, types.Function(_typing_ulong_iget_block))


@register
class _typing_ulonglong_iget_warp(ConcreteTemplate):
    key = globals()["ulonglong_iget_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(ulonglong_iget_warp, types.Function(_typing_ulonglong_iget_warp))


@register
class _typing_ulonglong_iget_block(ConcreteTemplate):
    key = globals()["ulonglong_iget_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(ulonglong_iget_block, types.Function(_typing_ulonglong_iget_block))


@register
class _typing_int8_iget_warp(ConcreteTemplate):
    key = globals()["int8_iget_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)]

register_global(int8_iget_warp, types.Function(_typing_int8_iget_warp))


@register
class _typing_int8_iget_block(ConcreteTemplate):
    key = globals()["int8_iget_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), int64, int64, uint64, int32)]

register_global(int8_iget_block, types.Function(_typing_int8_iget_block))


@register
class _typing_int16_iget_warp(ConcreteTemplate):
    key = globals()["int16_iget_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)]

register_global(int16_iget_warp, types.Function(_typing_int16_iget_warp))


@register
class _typing_int16_iget_block(ConcreteTemplate):
    key = globals()["int16_iget_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), int64, int64, uint64, int32)]

register_global(int16_iget_block, types.Function(_typing_int16_iget_block))


@register
class _typing_int32_iget_warp(ConcreteTemplate):
    key = globals()["int32_iget_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)]

register_global(int32_iget_warp, types.Function(_typing_int32_iget_warp))


@register
class _typing_int32_iget_block(ConcreteTemplate):
    key = globals()["int32_iget_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), int64, int64, uint64, int32)]

register_global(int32_iget_block, types.Function(_typing_int32_iget_block))


@register
class _typing_int64_iget_warp(ConcreteTemplate):
    key = globals()["int64_iget_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(int64_iget_warp, types.Function(_typing_int64_iget_warp))


@register
class _typing_int64_iget_block(ConcreteTemplate):
    key = globals()["int64_iget_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(int64_iget_block, types.Function(_typing_int64_iget_block))


@register
class _typing_uint8_iget_warp(ConcreteTemplate):
    key = globals()["uint8_iget_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)]

register_global(uint8_iget_warp, types.Function(_typing_uint8_iget_warp))


@register
class _typing_uint8_iget_block(ConcreteTemplate):
    key = globals()["uint8_iget_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), int64, int64, uint64, int32)]

register_global(uint8_iget_block, types.Function(_typing_uint8_iget_block))


@register
class _typing_uint16_iget_warp(ConcreteTemplate):
    key = globals()["uint16_iget_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)]

register_global(uint16_iget_warp, types.Function(_typing_uint16_iget_warp))


@register
class _typing_uint16_iget_block(ConcreteTemplate):
    key = globals()["uint16_iget_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), int64, int64, uint64, int32)]

register_global(uint16_iget_block, types.Function(_typing_uint16_iget_block))


@register
class _typing_uint32_iget_warp(ConcreteTemplate):
    key = globals()["uint32_iget_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)]

register_global(uint32_iget_warp, types.Function(_typing_uint32_iget_warp))


@register
class _typing_uint32_iget_block(ConcreteTemplate):
    key = globals()["uint32_iget_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), int64, int64, uint64, int32)]

register_global(uint32_iget_block, types.Function(_typing_uint32_iget_block))


@register
class _typing_uint64_iget_warp(ConcreteTemplate):
    key = globals()["uint64_iget_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(uint64_iget_warp, types.Function(_typing_uint64_iget_warp))


@register
class _typing_uint64_iget_block(ConcreteTemplate):
    key = globals()["uint64_iget_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(uint64_iget_block, types.Function(_typing_uint64_iget_block))


@register
class _typing_size_iget_warp(ConcreteTemplate):
    key = globals()["size_iget_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(size_iget_warp, types.Function(_typing_size_iget_warp))


@register
class _typing_size_iget_block(ConcreteTemplate):
    key = globals()["size_iget_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), int64, int64, uint64, int32)]

register_global(size_iget_block, types.Function(_typing_size_iget_block))


@register
class _typing_ptrdiff_iget_warp(ConcreteTemplate):
    key = globals()["ptrdiff_iget_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(ptrdiff_iget_warp, types.Function(_typing_ptrdiff_iget_warp))


@register
class _typing_ptrdiff_iget_block(ConcreteTemplate):
    key = globals()["ptrdiff_iget_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), int64, int64, uint64, int32)]

register_global(ptrdiff_iget_block, types.Function(_typing_ptrdiff_iget_block))


@register
class _typing_iget8_warp(ConcreteTemplate):
    key = globals()["iget8_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iget8_warp, types.Function(_typing_iget8_warp))


@register
class _typing_iget8_block(ConcreteTemplate):
    key = globals()["iget8_block"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iget8_block, types.Function(_typing_iget8_block))


@register
class _typing_iget16_warp(ConcreteTemplate):
    key = globals()["iget16_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iget16_warp, types.Function(_typing_iget16_warp))


@register
class _typing_iget16_block(ConcreteTemplate):
    key = globals()["iget16_block"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iget16_block, types.Function(_typing_iget16_block))


@register
class _typing_iget32_warp(ConcreteTemplate):
    key = globals()["iget32_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iget32_warp, types.Function(_typing_iget32_warp))


@register
class _typing_iget32_block(ConcreteTemplate):
    key = globals()["iget32_block"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iget32_block, types.Function(_typing_iget32_block))


@register
class _typing_iget64_warp(ConcreteTemplate):
    key = globals()["iget64_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iget64_warp, types.Function(_typing_iget64_warp))


@register
class _typing_iget64_block(ConcreteTemplate):
    key = globals()["iget64_block"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iget64_block, types.Function(_typing_iget64_block))


@register
class _typing_iget128_warp(ConcreteTemplate):
    key = globals()["iget128_warp"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iget128_warp, types.Function(_typing_iget128_warp))


@register
class _typing_iget128_block(ConcreteTemplate):
    key = globals()["iget128_block"]
    cases = [signature(void, CPointer(void), CPointer(void), int64, int64, uint64, int32)]

register_global(iget128_block, types.Function(_typing_iget128_block))


@register
class _typing_qp_bfloat16_get(ConcreteTemplate):
    key = globals()["qp_bfloat16_get"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)]

register_global(qp_bfloat16_get, types.Function(_typing_qp_bfloat16_get))


@register
class _typing_qp_bfloat16_get_warp(ConcreteTemplate):
    key = globals()["qp_bfloat16_get_warp"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)]

register_global(qp_bfloat16_get_warp, types.Function(_typing_qp_bfloat16_get_warp))


@register
class _typing_qp_bfloat16_get_block(ConcreteTemplate):
    key = globals()["qp_bfloat16_get_block"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)]

register_global(qp_bfloat16_get_block, types.Function(_typing_qp_bfloat16_get_block))


@register
class _typing_qp_half_get(ConcreteTemplate):
    key = globals()["qp_half_get"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32, int32)]

register_global(qp_half_get, types.Function(_typing_qp_half_get))


@register
class _typing_qp_half_get_warp(ConcreteTemplate):
    key = globals()["qp_half_get_warp"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32, int32)]

register_global(qp_half_get_warp, types.Function(_typing_qp_half_get_warp))


@register
class _typing_qp_half_get_block(ConcreteTemplate):
    key = globals()["qp_half_get_block"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32, int32)]

register_global(qp_half_get_block, types.Function(_typing_qp_half_get_block))


@register
class _typing_qp_float_get(ConcreteTemplate):
    key = globals()["qp_float_get"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32, int32)]

register_global(qp_float_get, types.Function(_typing_qp_float_get))


@register
class _typing_qp_float_get_warp(ConcreteTemplate):
    key = globals()["qp_float_get_warp"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32, int32)]

register_global(qp_float_get_warp, types.Function(_typing_qp_float_get_warp))


@register
class _typing_qp_float_get_block(ConcreteTemplate):
    key = globals()["qp_float_get_block"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32, int32)]

register_global(qp_float_get_block, types.Function(_typing_qp_float_get_block))


@register
class _typing_qp_double_get(ConcreteTemplate):
    key = globals()["qp_double_get"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32, int32)]

register_global(qp_double_get, types.Function(_typing_qp_double_get))


@register
class _typing_qp_double_get_warp(ConcreteTemplate):
    key = globals()["qp_double_get_warp"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32, int32)]

register_global(qp_double_get_warp, types.Function(_typing_qp_double_get_warp))


@register
class _typing_qp_double_get_block(ConcreteTemplate):
    key = globals()["qp_double_get_block"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32, int32)]

register_global(qp_double_get_block, types.Function(_typing_qp_double_get_block))


@register
class _typing_qp_char_get(ConcreteTemplate):
    key = globals()["qp_char_get"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_char_get, types.Function(_typing_qp_char_get))


@register
class _typing_qp_char_get_warp(ConcreteTemplate):
    key = globals()["qp_char_get_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_char_get_warp, types.Function(_typing_qp_char_get_warp))


@register
class _typing_qp_char_get_block(ConcreteTemplate):
    key = globals()["qp_char_get_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_char_get_block, types.Function(_typing_qp_char_get_block))


@register
class _typing_qp_short_get(ConcreteTemplate):
    key = globals()["qp_short_get"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_short_get, types.Function(_typing_qp_short_get))


@register
class _typing_qp_short_get_warp(ConcreteTemplate):
    key = globals()["qp_short_get_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_short_get_warp, types.Function(_typing_qp_short_get_warp))


@register
class _typing_qp_short_get_block(ConcreteTemplate):
    key = globals()["qp_short_get_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_short_get_block, types.Function(_typing_qp_short_get_block))


@register
class _typing_qp_schar_get(ConcreteTemplate):
    key = globals()["qp_schar_get"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_schar_get, types.Function(_typing_qp_schar_get))


@register
class _typing_qp_schar_get_warp(ConcreteTemplate):
    key = globals()["qp_schar_get_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_schar_get_warp, types.Function(_typing_qp_schar_get_warp))


@register
class _typing_qp_schar_get_block(ConcreteTemplate):
    key = globals()["qp_schar_get_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_schar_get_block, types.Function(_typing_qp_schar_get_block))


@register
class _typing_qp_int_get(ConcreteTemplate):
    key = globals()["qp_int_get"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int_get, types.Function(_typing_qp_int_get))


@register
class _typing_qp_int_get_warp(ConcreteTemplate):
    key = globals()["qp_int_get_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int_get_warp, types.Function(_typing_qp_int_get_warp))


@register
class _typing_qp_int_get_block(ConcreteTemplate):
    key = globals()["qp_int_get_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int_get_block, types.Function(_typing_qp_int_get_block))


@register
class _typing_qp_long_get(ConcreteTemplate):
    key = globals()["qp_long_get"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_long_get, types.Function(_typing_qp_long_get))


@register
class _typing_qp_long_get_warp(ConcreteTemplate):
    key = globals()["qp_long_get_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_long_get_warp, types.Function(_typing_qp_long_get_warp))


@register
class _typing_qp_long_get_block(ConcreteTemplate):
    key = globals()["qp_long_get_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_long_get_block, types.Function(_typing_qp_long_get_block))


@register
class _typing_qp_longlong_get(ConcreteTemplate):
    key = globals()["qp_longlong_get"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_longlong_get, types.Function(_typing_qp_longlong_get))


@register
class _typing_qp_longlong_get_warp(ConcreteTemplate):
    key = globals()["qp_longlong_get_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_longlong_get_warp, types.Function(_typing_qp_longlong_get_warp))


@register
class _typing_qp_longlong_get_block(ConcreteTemplate):
    key = globals()["qp_longlong_get_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_longlong_get_block, types.Function(_typing_qp_longlong_get_block))


@register
class _typing_qp_uchar_get(ConcreteTemplate):
    key = globals()["qp_uchar_get"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uchar_get, types.Function(_typing_qp_uchar_get))


@register
class _typing_qp_uchar_get_warp(ConcreteTemplate):
    key = globals()["qp_uchar_get_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uchar_get_warp, types.Function(_typing_qp_uchar_get_warp))


@register
class _typing_qp_uchar_get_block(ConcreteTemplate):
    key = globals()["qp_uchar_get_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uchar_get_block, types.Function(_typing_qp_uchar_get_block))


@register
class _typing_qp_ushort_get(ConcreteTemplate):
    key = globals()["qp_ushort_get"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_ushort_get, types.Function(_typing_qp_ushort_get))


@register
class _typing_qp_ushort_get_warp(ConcreteTemplate):
    key = globals()["qp_ushort_get_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_ushort_get_warp, types.Function(_typing_qp_ushort_get_warp))


@register
class _typing_qp_ushort_get_block(ConcreteTemplate):
    key = globals()["qp_ushort_get_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_ushort_get_block, types.Function(_typing_qp_ushort_get_block))


@register
class _typing_qp_uint_get(ConcreteTemplate):
    key = globals()["qp_uint_get"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint_get, types.Function(_typing_qp_uint_get))


@register
class _typing_qp_uint_get_warp(ConcreteTemplate):
    key = globals()["qp_uint_get_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint_get_warp, types.Function(_typing_qp_uint_get_warp))


@register
class _typing_qp_uint_get_block(ConcreteTemplate):
    key = globals()["qp_uint_get_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint_get_block, types.Function(_typing_qp_uint_get_block))


@register
class _typing_qp_ulong_get(ConcreteTemplate):
    key = globals()["qp_ulong_get"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulong_get, types.Function(_typing_qp_ulong_get))


@register
class _typing_qp_ulong_get_warp(ConcreteTemplate):
    key = globals()["qp_ulong_get_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulong_get_warp, types.Function(_typing_qp_ulong_get_warp))


@register
class _typing_qp_ulong_get_block(ConcreteTemplate):
    key = globals()["qp_ulong_get_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulong_get_block, types.Function(_typing_qp_ulong_get_block))


@register
class _typing_qp_ulonglong_get(ConcreteTemplate):
    key = globals()["qp_ulonglong_get"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulonglong_get, types.Function(_typing_qp_ulonglong_get))


@register
class _typing_qp_ulonglong_get_warp(ConcreteTemplate):
    key = globals()["qp_ulonglong_get_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulonglong_get_warp, types.Function(_typing_qp_ulonglong_get_warp))


@register
class _typing_qp_ulonglong_get_block(ConcreteTemplate):
    key = globals()["qp_ulonglong_get_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulonglong_get_block, types.Function(_typing_qp_ulonglong_get_block))


@register
class _typing_qp_int8_get(ConcreteTemplate):
    key = globals()["qp_int8_get"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_int8_get, types.Function(_typing_qp_int8_get))


@register
class _typing_qp_int8_get_warp(ConcreteTemplate):
    key = globals()["qp_int8_get_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_int8_get_warp, types.Function(_typing_qp_int8_get_warp))


@register
class _typing_qp_int8_get_block(ConcreteTemplate):
    key = globals()["qp_int8_get_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_int8_get_block, types.Function(_typing_qp_int8_get_block))


@register
class _typing_qp_int16_get(ConcreteTemplate):
    key = globals()["qp_int16_get"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_int16_get, types.Function(_typing_qp_int16_get))


@register
class _typing_qp_int16_get_warp(ConcreteTemplate):
    key = globals()["qp_int16_get_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_int16_get_warp, types.Function(_typing_qp_int16_get_warp))


@register
class _typing_qp_int16_get_block(ConcreteTemplate):
    key = globals()["qp_int16_get_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_int16_get_block, types.Function(_typing_qp_int16_get_block))


@register
class _typing_qp_int32_get(ConcreteTemplate):
    key = globals()["qp_int32_get"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int32_get, types.Function(_typing_qp_int32_get))


@register
class _typing_qp_int32_get_warp(ConcreteTemplate):
    key = globals()["qp_int32_get_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int32_get_warp, types.Function(_typing_qp_int32_get_warp))


@register
class _typing_qp_int32_get_block(ConcreteTemplate):
    key = globals()["qp_int32_get_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int32_get_block, types.Function(_typing_qp_int32_get_block))


@register
class _typing_qp_int64_get(ConcreteTemplate):
    key = globals()["qp_int64_get"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_int64_get, types.Function(_typing_qp_int64_get))


@register
class _typing_qp_int64_get_warp(ConcreteTemplate):
    key = globals()["qp_int64_get_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_int64_get_warp, types.Function(_typing_qp_int64_get_warp))


@register
class _typing_qp_int64_get_block(ConcreteTemplate):
    key = globals()["qp_int64_get_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_int64_get_block, types.Function(_typing_qp_int64_get_block))


@register
class _typing_qp_uint8_get(ConcreteTemplate):
    key = globals()["qp_uint8_get"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uint8_get, types.Function(_typing_qp_uint8_get))


@register
class _typing_qp_uint8_get_warp(ConcreteTemplate):
    key = globals()["qp_uint8_get_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uint8_get_warp, types.Function(_typing_qp_uint8_get_warp))


@register
class _typing_qp_uint8_get_block(ConcreteTemplate):
    key = globals()["qp_uint8_get_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uint8_get_block, types.Function(_typing_qp_uint8_get_block))


@register
class _typing_qp_uint16_get(ConcreteTemplate):
    key = globals()["qp_uint16_get"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_uint16_get, types.Function(_typing_qp_uint16_get))


@register
class _typing_qp_uint16_get_warp(ConcreteTemplate):
    key = globals()["qp_uint16_get_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_uint16_get_warp, types.Function(_typing_qp_uint16_get_warp))


@register
class _typing_qp_uint16_get_block(ConcreteTemplate):
    key = globals()["qp_uint16_get_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_uint16_get_block, types.Function(_typing_qp_uint16_get_block))


@register
class _typing_qp_uint32_get(ConcreteTemplate):
    key = globals()["qp_uint32_get"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint32_get, types.Function(_typing_qp_uint32_get))


@register
class _typing_qp_uint32_get_warp(ConcreteTemplate):
    key = globals()["qp_uint32_get_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint32_get_warp, types.Function(_typing_qp_uint32_get_warp))


@register
class _typing_qp_uint32_get_block(ConcreteTemplate):
    key = globals()["qp_uint32_get_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint32_get_block, types.Function(_typing_qp_uint32_get_block))


@register
class _typing_qp_uint64_get(ConcreteTemplate):
    key = globals()["qp_uint64_get"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_uint64_get, types.Function(_typing_qp_uint64_get))


@register
class _typing_qp_uint64_get_warp(ConcreteTemplate):
    key = globals()["qp_uint64_get_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_uint64_get_warp, types.Function(_typing_qp_uint64_get_warp))


@register
class _typing_qp_uint64_get_block(ConcreteTemplate):
    key = globals()["qp_uint64_get_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_uint64_get_block, types.Function(_typing_qp_uint64_get_block))


@register
class _typing_qp_size_get(ConcreteTemplate):
    key = globals()["qp_size_get"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_size_get, types.Function(_typing_qp_size_get))


@register
class _typing_qp_size_get_warp(ConcreteTemplate):
    key = globals()["qp_size_get_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_size_get_warp, types.Function(_typing_qp_size_get_warp))


@register
class _typing_qp_size_get_block(ConcreteTemplate):
    key = globals()["qp_size_get_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_size_get_block, types.Function(_typing_qp_size_get_block))


@register
class _typing_qp_ptrdiff_get(ConcreteTemplate):
    key = globals()["qp_ptrdiff_get"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_ptrdiff_get, types.Function(_typing_qp_ptrdiff_get))


@register
class _typing_qp_ptrdiff_get_warp(ConcreteTemplate):
    key = globals()["qp_ptrdiff_get_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_ptrdiff_get_warp, types.Function(_typing_qp_ptrdiff_get_warp))


@register
class _typing_qp_ptrdiff_get_block(ConcreteTemplate):
    key = globals()["qp_ptrdiff_get_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_ptrdiff_get_block, types.Function(_typing_qp_ptrdiff_get_block))


@register
class _typing_qp_bfloat16_get_nbi(ConcreteTemplate):
    key = globals()["qp_bfloat16_get_nbi"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)]

register_global(qp_bfloat16_get_nbi, types.Function(_typing_qp_bfloat16_get_nbi))


@register
class _typing_qp_bfloat16_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_bfloat16_get_nbi_warp"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)]

register_global(qp_bfloat16_get_nbi_warp, types.Function(_typing_qp_bfloat16_get_nbi_warp))


@register
class _typing_qp_bfloat16_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_bfloat16_get_nbi_block"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)]

register_global(qp_bfloat16_get_nbi_block, types.Function(_typing_qp_bfloat16_get_nbi_block))


@register
class _typing_qp_half_get_nbi(ConcreteTemplate):
    key = globals()["qp_half_get_nbi"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32, int32)]

register_global(qp_half_get_nbi, types.Function(_typing_qp_half_get_nbi))


@register
class _typing_qp_half_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_half_get_nbi_warp"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32, int32)]

register_global(qp_half_get_nbi_warp, types.Function(_typing_qp_half_get_nbi_warp))


@register
class _typing_qp_half_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_half_get_nbi_block"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32, int32)]

register_global(qp_half_get_nbi_block, types.Function(_typing_qp_half_get_nbi_block))


@register
class _typing_qp_float_get_nbi(ConcreteTemplate):
    key = globals()["qp_float_get_nbi"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32, int32)]

register_global(qp_float_get_nbi, types.Function(_typing_qp_float_get_nbi))


@register
class _typing_qp_float_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_float_get_nbi_warp"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32, int32)]

register_global(qp_float_get_nbi_warp, types.Function(_typing_qp_float_get_nbi_warp))


@register
class _typing_qp_float_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_float_get_nbi_block"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32, int32)]

register_global(qp_float_get_nbi_block, types.Function(_typing_qp_float_get_nbi_block))


@register
class _typing_qp_double_get_nbi(ConcreteTemplate):
    key = globals()["qp_double_get_nbi"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32, int32)]

register_global(qp_double_get_nbi, types.Function(_typing_qp_double_get_nbi))


@register
class _typing_qp_double_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_double_get_nbi_warp"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32, int32)]

register_global(qp_double_get_nbi_warp, types.Function(_typing_qp_double_get_nbi_warp))


@register
class _typing_qp_double_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_double_get_nbi_block"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32, int32)]

register_global(qp_double_get_nbi_block, types.Function(_typing_qp_double_get_nbi_block))


@register
class _typing_qp_char_get_nbi(ConcreteTemplate):
    key = globals()["qp_char_get_nbi"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_char_get_nbi, types.Function(_typing_qp_char_get_nbi))


@register
class _typing_qp_char_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_char_get_nbi_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_char_get_nbi_warp, types.Function(_typing_qp_char_get_nbi_warp))


@register
class _typing_qp_char_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_char_get_nbi_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_char_get_nbi_block, types.Function(_typing_qp_char_get_nbi_block))


@register
class _typing_qp_short_get_nbi(ConcreteTemplate):
    key = globals()["qp_short_get_nbi"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_short_get_nbi, types.Function(_typing_qp_short_get_nbi))


@register
class _typing_qp_short_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_short_get_nbi_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_short_get_nbi_warp, types.Function(_typing_qp_short_get_nbi_warp))


@register
class _typing_qp_short_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_short_get_nbi_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_short_get_nbi_block, types.Function(_typing_qp_short_get_nbi_block))


@register
class _typing_qp_schar_get_nbi(ConcreteTemplate):
    key = globals()["qp_schar_get_nbi"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_schar_get_nbi, types.Function(_typing_qp_schar_get_nbi))


@register
class _typing_qp_schar_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_schar_get_nbi_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_schar_get_nbi_warp, types.Function(_typing_qp_schar_get_nbi_warp))


@register
class _typing_qp_schar_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_schar_get_nbi_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_schar_get_nbi_block, types.Function(_typing_qp_schar_get_nbi_block))


@register
class _typing_qp_int_get_nbi(ConcreteTemplate):
    key = globals()["qp_int_get_nbi"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int_get_nbi, types.Function(_typing_qp_int_get_nbi))


@register
class _typing_qp_int_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_int_get_nbi_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int_get_nbi_warp, types.Function(_typing_qp_int_get_nbi_warp))


@register
class _typing_qp_int_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_int_get_nbi_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int_get_nbi_block, types.Function(_typing_qp_int_get_nbi_block))


@register
class _typing_qp_long_get_nbi(ConcreteTemplate):
    key = globals()["qp_long_get_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_long_get_nbi, types.Function(_typing_qp_long_get_nbi))


@register
class _typing_qp_long_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_long_get_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_long_get_nbi_warp, types.Function(_typing_qp_long_get_nbi_warp))


@register
class _typing_qp_long_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_long_get_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_long_get_nbi_block, types.Function(_typing_qp_long_get_nbi_block))


@register
class _typing_qp_longlong_get_nbi(ConcreteTemplate):
    key = globals()["qp_longlong_get_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_longlong_get_nbi, types.Function(_typing_qp_longlong_get_nbi))


@register
class _typing_qp_longlong_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_longlong_get_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_longlong_get_nbi_warp, types.Function(_typing_qp_longlong_get_nbi_warp))


@register
class _typing_qp_longlong_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_longlong_get_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_longlong_get_nbi_block, types.Function(_typing_qp_longlong_get_nbi_block))


@register
class _typing_qp_uchar_get_nbi(ConcreteTemplate):
    key = globals()["qp_uchar_get_nbi"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uchar_get_nbi, types.Function(_typing_qp_uchar_get_nbi))


@register
class _typing_qp_uchar_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_uchar_get_nbi_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uchar_get_nbi_warp, types.Function(_typing_qp_uchar_get_nbi_warp))


@register
class _typing_qp_uchar_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_uchar_get_nbi_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uchar_get_nbi_block, types.Function(_typing_qp_uchar_get_nbi_block))


@register
class _typing_qp_ushort_get_nbi(ConcreteTemplate):
    key = globals()["qp_ushort_get_nbi"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_ushort_get_nbi, types.Function(_typing_qp_ushort_get_nbi))


@register
class _typing_qp_ushort_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_ushort_get_nbi_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_ushort_get_nbi_warp, types.Function(_typing_qp_ushort_get_nbi_warp))


@register
class _typing_qp_ushort_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_ushort_get_nbi_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_ushort_get_nbi_block, types.Function(_typing_qp_ushort_get_nbi_block))


@register
class _typing_qp_uint_get_nbi(ConcreteTemplate):
    key = globals()["qp_uint_get_nbi"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint_get_nbi, types.Function(_typing_qp_uint_get_nbi))


@register
class _typing_qp_uint_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_uint_get_nbi_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint_get_nbi_warp, types.Function(_typing_qp_uint_get_nbi_warp))


@register
class _typing_qp_uint_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_uint_get_nbi_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint_get_nbi_block, types.Function(_typing_qp_uint_get_nbi_block))


@register
class _typing_qp_ulong_get_nbi(ConcreteTemplate):
    key = globals()["qp_ulong_get_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulong_get_nbi, types.Function(_typing_qp_ulong_get_nbi))


@register
class _typing_qp_ulong_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_ulong_get_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulong_get_nbi_warp, types.Function(_typing_qp_ulong_get_nbi_warp))


@register
class _typing_qp_ulong_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_ulong_get_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulong_get_nbi_block, types.Function(_typing_qp_ulong_get_nbi_block))


@register
class _typing_qp_ulonglong_get_nbi(ConcreteTemplate):
    key = globals()["qp_ulonglong_get_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulonglong_get_nbi, types.Function(_typing_qp_ulonglong_get_nbi))


@register
class _typing_qp_ulonglong_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_ulonglong_get_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulonglong_get_nbi_warp, types.Function(_typing_qp_ulonglong_get_nbi_warp))


@register
class _typing_qp_ulonglong_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_ulonglong_get_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulonglong_get_nbi_block, types.Function(_typing_qp_ulonglong_get_nbi_block))


@register
class _typing_qp_int8_get_nbi(ConcreteTemplate):
    key = globals()["qp_int8_get_nbi"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_int8_get_nbi, types.Function(_typing_qp_int8_get_nbi))


@register
class _typing_qp_int8_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_int8_get_nbi_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_int8_get_nbi_warp, types.Function(_typing_qp_int8_get_nbi_warp))


@register
class _typing_qp_int8_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_int8_get_nbi_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_int8_get_nbi_block, types.Function(_typing_qp_int8_get_nbi_block))


@register
class _typing_qp_int16_get_nbi(ConcreteTemplate):
    key = globals()["qp_int16_get_nbi"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_int16_get_nbi, types.Function(_typing_qp_int16_get_nbi))


@register
class _typing_qp_int16_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_int16_get_nbi_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_int16_get_nbi_warp, types.Function(_typing_qp_int16_get_nbi_warp))


@register
class _typing_qp_int16_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_int16_get_nbi_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_int16_get_nbi_block, types.Function(_typing_qp_int16_get_nbi_block))


@register
class _typing_qp_int32_get_nbi(ConcreteTemplate):
    key = globals()["qp_int32_get_nbi"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int32_get_nbi, types.Function(_typing_qp_int32_get_nbi))


@register
class _typing_qp_int32_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_int32_get_nbi_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int32_get_nbi_warp, types.Function(_typing_qp_int32_get_nbi_warp))


@register
class _typing_qp_int32_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_int32_get_nbi_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int32_get_nbi_block, types.Function(_typing_qp_int32_get_nbi_block))


@register
class _typing_qp_int64_get_nbi(ConcreteTemplate):
    key = globals()["qp_int64_get_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_int64_get_nbi, types.Function(_typing_qp_int64_get_nbi))


@register
class _typing_qp_int64_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_int64_get_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_int64_get_nbi_warp, types.Function(_typing_qp_int64_get_nbi_warp))


@register
class _typing_qp_int64_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_int64_get_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_int64_get_nbi_block, types.Function(_typing_qp_int64_get_nbi_block))


@register
class _typing_qp_uint8_get_nbi(ConcreteTemplate):
    key = globals()["qp_uint8_get_nbi"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uint8_get_nbi, types.Function(_typing_qp_uint8_get_nbi))


@register
class _typing_qp_uint8_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_uint8_get_nbi_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uint8_get_nbi_warp, types.Function(_typing_qp_uint8_get_nbi_warp))


@register
class _typing_qp_uint8_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_uint8_get_nbi_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uint8_get_nbi_block, types.Function(_typing_qp_uint8_get_nbi_block))


@register
class _typing_qp_uint16_get_nbi(ConcreteTemplate):
    key = globals()["qp_uint16_get_nbi"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_uint16_get_nbi, types.Function(_typing_qp_uint16_get_nbi))


@register
class _typing_qp_uint16_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_uint16_get_nbi_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_uint16_get_nbi_warp, types.Function(_typing_qp_uint16_get_nbi_warp))


@register
class _typing_qp_uint16_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_uint16_get_nbi_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_uint16_get_nbi_block, types.Function(_typing_qp_uint16_get_nbi_block))


@register
class _typing_qp_uint32_get_nbi(ConcreteTemplate):
    key = globals()["qp_uint32_get_nbi"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint32_get_nbi, types.Function(_typing_qp_uint32_get_nbi))


@register
class _typing_qp_uint32_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_uint32_get_nbi_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint32_get_nbi_warp, types.Function(_typing_qp_uint32_get_nbi_warp))


@register
class _typing_qp_uint32_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_uint32_get_nbi_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint32_get_nbi_block, types.Function(_typing_qp_uint32_get_nbi_block))


@register
class _typing_qp_uint64_get_nbi(ConcreteTemplate):
    key = globals()["qp_uint64_get_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_uint64_get_nbi, types.Function(_typing_qp_uint64_get_nbi))


@register
class _typing_qp_uint64_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_uint64_get_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_uint64_get_nbi_warp, types.Function(_typing_qp_uint64_get_nbi_warp))


@register
class _typing_qp_uint64_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_uint64_get_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_uint64_get_nbi_block, types.Function(_typing_qp_uint64_get_nbi_block))


@register
class _typing_qp_size_get_nbi(ConcreteTemplate):
    key = globals()["qp_size_get_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_size_get_nbi, types.Function(_typing_qp_size_get_nbi))


@register
class _typing_qp_size_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_size_get_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_size_get_nbi_warp, types.Function(_typing_qp_size_get_nbi_warp))


@register
class _typing_qp_size_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_size_get_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_size_get_nbi_block, types.Function(_typing_qp_size_get_nbi_block))


@register
class _typing_qp_ptrdiff_get_nbi(ConcreteTemplate):
    key = globals()["qp_ptrdiff_get_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_ptrdiff_get_nbi, types.Function(_typing_qp_ptrdiff_get_nbi))


@register
class _typing_qp_ptrdiff_get_nbi_warp(ConcreteTemplate):
    key = globals()["qp_ptrdiff_get_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_ptrdiff_get_nbi_warp, types.Function(_typing_qp_ptrdiff_get_nbi_warp))


@register
class _typing_qp_ptrdiff_get_nbi_block(ConcreteTemplate):
    key = globals()["qp_ptrdiff_get_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_ptrdiff_get_nbi_block, types.Function(_typing_qp_ptrdiff_get_nbi_block))


@register
class _typing_qp_bfloat16_put(ConcreteTemplate):
    key = globals()["qp_bfloat16_put"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)]

register_global(qp_bfloat16_put, types.Function(_typing_qp_bfloat16_put))


@register
class _typing_qp_bfloat16_put_warp(ConcreteTemplate):
    key = globals()["qp_bfloat16_put_warp"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)]

register_global(qp_bfloat16_put_warp, types.Function(_typing_qp_bfloat16_put_warp))


@register
class _typing_qp_bfloat16_put_block(ConcreteTemplate):
    key = globals()["qp_bfloat16_put_block"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)]

register_global(qp_bfloat16_put_block, types.Function(_typing_qp_bfloat16_put_block))


@register
class _typing_qp_half_put(ConcreteTemplate):
    key = globals()["qp_half_put"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32, int32)]

register_global(qp_half_put, types.Function(_typing_qp_half_put))


@register
class _typing_qp_half_put_warp(ConcreteTemplate):
    key = globals()["qp_half_put_warp"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32, int32)]

register_global(qp_half_put_warp, types.Function(_typing_qp_half_put_warp))


@register
class _typing_qp_half_put_block(ConcreteTemplate):
    key = globals()["qp_half_put_block"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32, int32)]

register_global(qp_half_put_block, types.Function(_typing_qp_half_put_block))


@register
class _typing_qp_float_put(ConcreteTemplate):
    key = globals()["qp_float_put"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32, int32)]

register_global(qp_float_put, types.Function(_typing_qp_float_put))


@register
class _typing_qp_float_put_warp(ConcreteTemplate):
    key = globals()["qp_float_put_warp"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32, int32)]

register_global(qp_float_put_warp, types.Function(_typing_qp_float_put_warp))


@register
class _typing_qp_float_put_block(ConcreteTemplate):
    key = globals()["qp_float_put_block"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32, int32)]

register_global(qp_float_put_block, types.Function(_typing_qp_float_put_block))


@register
class _typing_qp_double_put(ConcreteTemplate):
    key = globals()["qp_double_put"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32, int32)]

register_global(qp_double_put, types.Function(_typing_qp_double_put))


@register
class _typing_qp_double_put_warp(ConcreteTemplate):
    key = globals()["qp_double_put_warp"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32, int32)]

register_global(qp_double_put_warp, types.Function(_typing_qp_double_put_warp))


@register
class _typing_qp_double_put_block(ConcreteTemplate):
    key = globals()["qp_double_put_block"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32, int32)]

register_global(qp_double_put_block, types.Function(_typing_qp_double_put_block))


@register
class _typing_qp_char_put(ConcreteTemplate):
    key = globals()["qp_char_put"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_char_put, types.Function(_typing_qp_char_put))


@register
class _typing_qp_char_put_warp(ConcreteTemplate):
    key = globals()["qp_char_put_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_char_put_warp, types.Function(_typing_qp_char_put_warp))


@register
class _typing_qp_char_put_block(ConcreteTemplate):
    key = globals()["qp_char_put_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_char_put_block, types.Function(_typing_qp_char_put_block))


@register
class _typing_qp_short_put(ConcreteTemplate):
    key = globals()["qp_short_put"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_short_put, types.Function(_typing_qp_short_put))


@register
class _typing_qp_short_put_warp(ConcreteTemplate):
    key = globals()["qp_short_put_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_short_put_warp, types.Function(_typing_qp_short_put_warp))


@register
class _typing_qp_short_put_block(ConcreteTemplate):
    key = globals()["qp_short_put_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_short_put_block, types.Function(_typing_qp_short_put_block))


@register
class _typing_qp_schar_put(ConcreteTemplate):
    key = globals()["qp_schar_put"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_schar_put, types.Function(_typing_qp_schar_put))


@register
class _typing_qp_schar_put_warp(ConcreteTemplate):
    key = globals()["qp_schar_put_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_schar_put_warp, types.Function(_typing_qp_schar_put_warp))


@register
class _typing_qp_schar_put_block(ConcreteTemplate):
    key = globals()["qp_schar_put_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_schar_put_block, types.Function(_typing_qp_schar_put_block))


@register
class _typing_qp_int_put(ConcreteTemplate):
    key = globals()["qp_int_put"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int_put, types.Function(_typing_qp_int_put))


@register
class _typing_qp_int_put_warp(ConcreteTemplate):
    key = globals()["qp_int_put_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int_put_warp, types.Function(_typing_qp_int_put_warp))


@register
class _typing_qp_int_put_block(ConcreteTemplate):
    key = globals()["qp_int_put_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int_put_block, types.Function(_typing_qp_int_put_block))


@register
class _typing_qp_long_put(ConcreteTemplate):
    key = globals()["qp_long_put"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_long_put, types.Function(_typing_qp_long_put))


@register
class _typing_qp_long_put_warp(ConcreteTemplate):
    key = globals()["qp_long_put_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_long_put_warp, types.Function(_typing_qp_long_put_warp))


@register
class _typing_qp_long_put_block(ConcreteTemplate):
    key = globals()["qp_long_put_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_long_put_block, types.Function(_typing_qp_long_put_block))


@register
class _typing_qp_longlong_put(ConcreteTemplate):
    key = globals()["qp_longlong_put"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_longlong_put, types.Function(_typing_qp_longlong_put))


@register
class _typing_qp_longlong_put_warp(ConcreteTemplate):
    key = globals()["qp_longlong_put_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_longlong_put_warp, types.Function(_typing_qp_longlong_put_warp))


@register
class _typing_qp_longlong_put_block(ConcreteTemplate):
    key = globals()["qp_longlong_put_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_longlong_put_block, types.Function(_typing_qp_longlong_put_block))


@register
class _typing_qp_uchar_put(ConcreteTemplate):
    key = globals()["qp_uchar_put"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uchar_put, types.Function(_typing_qp_uchar_put))


@register
class _typing_qp_uchar_put_warp(ConcreteTemplate):
    key = globals()["qp_uchar_put_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uchar_put_warp, types.Function(_typing_qp_uchar_put_warp))


@register
class _typing_qp_uchar_put_block(ConcreteTemplate):
    key = globals()["qp_uchar_put_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uchar_put_block, types.Function(_typing_qp_uchar_put_block))


@register
class _typing_qp_ushort_put(ConcreteTemplate):
    key = globals()["qp_ushort_put"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_ushort_put, types.Function(_typing_qp_ushort_put))


@register
class _typing_qp_ushort_put_warp(ConcreteTemplate):
    key = globals()["qp_ushort_put_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_ushort_put_warp, types.Function(_typing_qp_ushort_put_warp))


@register
class _typing_qp_ushort_put_block(ConcreteTemplate):
    key = globals()["qp_ushort_put_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_ushort_put_block, types.Function(_typing_qp_ushort_put_block))


@register
class _typing_qp_uint_put(ConcreteTemplate):
    key = globals()["qp_uint_put"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint_put, types.Function(_typing_qp_uint_put))


@register
class _typing_qp_uint_put_warp(ConcreteTemplate):
    key = globals()["qp_uint_put_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint_put_warp, types.Function(_typing_qp_uint_put_warp))


@register
class _typing_qp_uint_put_block(ConcreteTemplate):
    key = globals()["qp_uint_put_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint_put_block, types.Function(_typing_qp_uint_put_block))


@register
class _typing_qp_ulong_put(ConcreteTemplate):
    key = globals()["qp_ulong_put"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulong_put, types.Function(_typing_qp_ulong_put))


@register
class _typing_qp_ulong_put_warp(ConcreteTemplate):
    key = globals()["qp_ulong_put_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulong_put_warp, types.Function(_typing_qp_ulong_put_warp))


@register
class _typing_qp_ulong_put_block(ConcreteTemplate):
    key = globals()["qp_ulong_put_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulong_put_block, types.Function(_typing_qp_ulong_put_block))


@register
class _typing_qp_ulonglong_put(ConcreteTemplate):
    key = globals()["qp_ulonglong_put"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulonglong_put, types.Function(_typing_qp_ulonglong_put))


@register
class _typing_qp_ulonglong_put_warp(ConcreteTemplate):
    key = globals()["qp_ulonglong_put_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulonglong_put_warp, types.Function(_typing_qp_ulonglong_put_warp))


@register
class _typing_qp_ulonglong_put_block(ConcreteTemplate):
    key = globals()["qp_ulonglong_put_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulonglong_put_block, types.Function(_typing_qp_ulonglong_put_block))


@register
class _typing_qp_int8_put(ConcreteTemplate):
    key = globals()["qp_int8_put"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_int8_put, types.Function(_typing_qp_int8_put))


@register
class _typing_qp_int8_put_warp(ConcreteTemplate):
    key = globals()["qp_int8_put_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_int8_put_warp, types.Function(_typing_qp_int8_put_warp))


@register
class _typing_qp_int8_put_block(ConcreteTemplate):
    key = globals()["qp_int8_put_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_int8_put_block, types.Function(_typing_qp_int8_put_block))


@register
class _typing_qp_int16_put(ConcreteTemplate):
    key = globals()["qp_int16_put"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_int16_put, types.Function(_typing_qp_int16_put))


@register
class _typing_qp_int16_put_warp(ConcreteTemplate):
    key = globals()["qp_int16_put_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_int16_put_warp, types.Function(_typing_qp_int16_put_warp))


@register
class _typing_qp_int16_put_block(ConcreteTemplate):
    key = globals()["qp_int16_put_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_int16_put_block, types.Function(_typing_qp_int16_put_block))


@register
class _typing_qp_int32_put(ConcreteTemplate):
    key = globals()["qp_int32_put"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int32_put, types.Function(_typing_qp_int32_put))


@register
class _typing_qp_int32_put_warp(ConcreteTemplate):
    key = globals()["qp_int32_put_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int32_put_warp, types.Function(_typing_qp_int32_put_warp))


@register
class _typing_qp_int32_put_block(ConcreteTemplate):
    key = globals()["qp_int32_put_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int32_put_block, types.Function(_typing_qp_int32_put_block))


@register
class _typing_qp_int64_put(ConcreteTemplate):
    key = globals()["qp_int64_put"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_int64_put, types.Function(_typing_qp_int64_put))


@register
class _typing_qp_int64_put_warp(ConcreteTemplate):
    key = globals()["qp_int64_put_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_int64_put_warp, types.Function(_typing_qp_int64_put_warp))


@register
class _typing_qp_int64_put_block(ConcreteTemplate):
    key = globals()["qp_int64_put_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_int64_put_block, types.Function(_typing_qp_int64_put_block))


@register
class _typing_qp_uint8_put(ConcreteTemplate):
    key = globals()["qp_uint8_put"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uint8_put, types.Function(_typing_qp_uint8_put))


@register
class _typing_qp_uint8_put_warp(ConcreteTemplate):
    key = globals()["qp_uint8_put_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uint8_put_warp, types.Function(_typing_qp_uint8_put_warp))


@register
class _typing_qp_uint8_put_block(ConcreteTemplate):
    key = globals()["qp_uint8_put_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uint8_put_block, types.Function(_typing_qp_uint8_put_block))


@register
class _typing_qp_uint16_put(ConcreteTemplate):
    key = globals()["qp_uint16_put"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_uint16_put, types.Function(_typing_qp_uint16_put))


@register
class _typing_qp_uint16_put_warp(ConcreteTemplate):
    key = globals()["qp_uint16_put_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_uint16_put_warp, types.Function(_typing_qp_uint16_put_warp))


@register
class _typing_qp_uint16_put_block(ConcreteTemplate):
    key = globals()["qp_uint16_put_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_uint16_put_block, types.Function(_typing_qp_uint16_put_block))


@register
class _typing_qp_uint32_put(ConcreteTemplate):
    key = globals()["qp_uint32_put"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint32_put, types.Function(_typing_qp_uint32_put))


@register
class _typing_qp_uint32_put_warp(ConcreteTemplate):
    key = globals()["qp_uint32_put_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint32_put_warp, types.Function(_typing_qp_uint32_put_warp))


@register
class _typing_qp_uint32_put_block(ConcreteTemplate):
    key = globals()["qp_uint32_put_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint32_put_block, types.Function(_typing_qp_uint32_put_block))


@register
class _typing_qp_uint64_put(ConcreteTemplate):
    key = globals()["qp_uint64_put"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_uint64_put, types.Function(_typing_qp_uint64_put))


@register
class _typing_qp_uint64_put_warp(ConcreteTemplate):
    key = globals()["qp_uint64_put_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_uint64_put_warp, types.Function(_typing_qp_uint64_put_warp))


@register
class _typing_qp_uint64_put_block(ConcreteTemplate):
    key = globals()["qp_uint64_put_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_uint64_put_block, types.Function(_typing_qp_uint64_put_block))


@register
class _typing_qp_size_put(ConcreteTemplate):
    key = globals()["qp_size_put"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_size_put, types.Function(_typing_qp_size_put))


@register
class _typing_qp_size_put_warp(ConcreteTemplate):
    key = globals()["qp_size_put_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_size_put_warp, types.Function(_typing_qp_size_put_warp))


@register
class _typing_qp_size_put_block(ConcreteTemplate):
    key = globals()["qp_size_put_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_size_put_block, types.Function(_typing_qp_size_put_block))


@register
class _typing_qp_ptrdiff_put(ConcreteTemplate):
    key = globals()["qp_ptrdiff_put"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_ptrdiff_put, types.Function(_typing_qp_ptrdiff_put))


@register
class _typing_qp_ptrdiff_put_warp(ConcreteTemplate):
    key = globals()["qp_ptrdiff_put_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_ptrdiff_put_warp, types.Function(_typing_qp_ptrdiff_put_warp))


@register
class _typing_qp_ptrdiff_put_block(ConcreteTemplate):
    key = globals()["qp_ptrdiff_put_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_ptrdiff_put_block, types.Function(_typing_qp_ptrdiff_put_block))


@register
class _typing_qp_bfloat16_put_nbi(ConcreteTemplate):
    key = globals()["qp_bfloat16_put_nbi"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)]

register_global(qp_bfloat16_put_nbi, types.Function(_typing_qp_bfloat16_put_nbi))


@register
class _typing_qp_bfloat16_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_bfloat16_put_nbi_warp"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)]

register_global(qp_bfloat16_put_nbi_warp, types.Function(_typing_qp_bfloat16_put_nbi_warp))


@register
class _typing_qp_bfloat16_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_bfloat16_put_nbi_block"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, int32, int32)]

register_global(qp_bfloat16_put_nbi_block, types.Function(_typing_qp_bfloat16_put_nbi_block))


@register
class _typing_qp_half_put_nbi(ConcreteTemplate):
    key = globals()["qp_half_put_nbi"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32, int32)]

register_global(qp_half_put_nbi, types.Function(_typing_qp_half_put_nbi))


@register
class _typing_qp_half_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_half_put_nbi_warp"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32, int32)]

register_global(qp_half_put_nbi_warp, types.Function(_typing_qp_half_put_nbi_warp))


@register
class _typing_qp_half_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_half_put_nbi_block"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, int32, int32)]

register_global(qp_half_put_nbi_block, types.Function(_typing_qp_half_put_nbi_block))


@register
class _typing_qp_float_put_nbi(ConcreteTemplate):
    key = globals()["qp_float_put_nbi"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32, int32)]

register_global(qp_float_put_nbi, types.Function(_typing_qp_float_put_nbi))


@register
class _typing_qp_float_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_float_put_nbi_warp"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32, int32)]

register_global(qp_float_put_nbi_warp, types.Function(_typing_qp_float_put_nbi_warp))


@register
class _typing_qp_float_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_float_put_nbi_block"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, int32, int32)]

register_global(qp_float_put_nbi_block, types.Function(_typing_qp_float_put_nbi_block))


@register
class _typing_qp_double_put_nbi(ConcreteTemplate):
    key = globals()["qp_double_put_nbi"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32, int32)]

register_global(qp_double_put_nbi, types.Function(_typing_qp_double_put_nbi))


@register
class _typing_qp_double_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_double_put_nbi_warp"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32, int32)]

register_global(qp_double_put_nbi_warp, types.Function(_typing_qp_double_put_nbi_warp))


@register
class _typing_qp_double_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_double_put_nbi_block"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, int32, int32)]

register_global(qp_double_put_nbi_block, types.Function(_typing_qp_double_put_nbi_block))


@register
class _typing_qp_char_put_nbi(ConcreteTemplate):
    key = globals()["qp_char_put_nbi"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_char_put_nbi, types.Function(_typing_qp_char_put_nbi))


@register
class _typing_qp_char_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_char_put_nbi_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_char_put_nbi_warp, types.Function(_typing_qp_char_put_nbi_warp))


@register
class _typing_qp_char_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_char_put_nbi_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_char_put_nbi_block, types.Function(_typing_qp_char_put_nbi_block))


@register
class _typing_qp_short_put_nbi(ConcreteTemplate):
    key = globals()["qp_short_put_nbi"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_short_put_nbi, types.Function(_typing_qp_short_put_nbi))


@register
class _typing_qp_short_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_short_put_nbi_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_short_put_nbi_warp, types.Function(_typing_qp_short_put_nbi_warp))


@register
class _typing_qp_short_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_short_put_nbi_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_short_put_nbi_block, types.Function(_typing_qp_short_put_nbi_block))


@register
class _typing_qp_schar_put_nbi(ConcreteTemplate):
    key = globals()["qp_schar_put_nbi"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_schar_put_nbi, types.Function(_typing_qp_schar_put_nbi))


@register
class _typing_qp_schar_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_schar_put_nbi_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_schar_put_nbi_warp, types.Function(_typing_qp_schar_put_nbi_warp))


@register
class _typing_qp_schar_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_schar_put_nbi_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_schar_put_nbi_block, types.Function(_typing_qp_schar_put_nbi_block))


@register
class _typing_qp_int_put_nbi(ConcreteTemplate):
    key = globals()["qp_int_put_nbi"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int_put_nbi, types.Function(_typing_qp_int_put_nbi))


@register
class _typing_qp_int_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_int_put_nbi_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int_put_nbi_warp, types.Function(_typing_qp_int_put_nbi_warp))


@register
class _typing_qp_int_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_int_put_nbi_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int_put_nbi_block, types.Function(_typing_qp_int_put_nbi_block))


@register
class _typing_qp_long_put_nbi(ConcreteTemplate):
    key = globals()["qp_long_put_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_long_put_nbi, types.Function(_typing_qp_long_put_nbi))


@register
class _typing_qp_long_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_long_put_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_long_put_nbi_warp, types.Function(_typing_qp_long_put_nbi_warp))


@register
class _typing_qp_long_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_long_put_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_long_put_nbi_block, types.Function(_typing_qp_long_put_nbi_block))


@register
class _typing_qp_longlong_put_nbi(ConcreteTemplate):
    key = globals()["qp_longlong_put_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_longlong_put_nbi, types.Function(_typing_qp_longlong_put_nbi))


@register
class _typing_qp_longlong_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_longlong_put_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_longlong_put_nbi_warp, types.Function(_typing_qp_longlong_put_nbi_warp))


@register
class _typing_qp_longlong_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_longlong_put_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_longlong_put_nbi_block, types.Function(_typing_qp_longlong_put_nbi_block))


@register
class _typing_qp_uchar_put_nbi(ConcreteTemplate):
    key = globals()["qp_uchar_put_nbi"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uchar_put_nbi, types.Function(_typing_qp_uchar_put_nbi))


@register
class _typing_qp_uchar_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_uchar_put_nbi_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uchar_put_nbi_warp, types.Function(_typing_qp_uchar_put_nbi_warp))


@register
class _typing_qp_uchar_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_uchar_put_nbi_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uchar_put_nbi_block, types.Function(_typing_qp_uchar_put_nbi_block))


@register
class _typing_qp_ushort_put_nbi(ConcreteTemplate):
    key = globals()["qp_ushort_put_nbi"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_ushort_put_nbi, types.Function(_typing_qp_ushort_put_nbi))


@register
class _typing_qp_ushort_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_ushort_put_nbi_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_ushort_put_nbi_warp, types.Function(_typing_qp_ushort_put_nbi_warp))


@register
class _typing_qp_ushort_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_ushort_put_nbi_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_ushort_put_nbi_block, types.Function(_typing_qp_ushort_put_nbi_block))


@register
class _typing_qp_uint_put_nbi(ConcreteTemplate):
    key = globals()["qp_uint_put_nbi"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint_put_nbi, types.Function(_typing_qp_uint_put_nbi))


@register
class _typing_qp_uint_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_uint_put_nbi_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint_put_nbi_warp, types.Function(_typing_qp_uint_put_nbi_warp))


@register
class _typing_qp_uint_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_uint_put_nbi_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint_put_nbi_block, types.Function(_typing_qp_uint_put_nbi_block))


@register
class _typing_qp_ulong_put_nbi(ConcreteTemplate):
    key = globals()["qp_ulong_put_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulong_put_nbi, types.Function(_typing_qp_ulong_put_nbi))


@register
class _typing_qp_ulong_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_ulong_put_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulong_put_nbi_warp, types.Function(_typing_qp_ulong_put_nbi_warp))


@register
class _typing_qp_ulong_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_ulong_put_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulong_put_nbi_block, types.Function(_typing_qp_ulong_put_nbi_block))


@register
class _typing_qp_ulonglong_put_nbi(ConcreteTemplate):
    key = globals()["qp_ulonglong_put_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulonglong_put_nbi, types.Function(_typing_qp_ulonglong_put_nbi))


@register
class _typing_qp_ulonglong_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_ulonglong_put_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulonglong_put_nbi_warp, types.Function(_typing_qp_ulonglong_put_nbi_warp))


@register
class _typing_qp_ulonglong_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_ulonglong_put_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulonglong_put_nbi_block, types.Function(_typing_qp_ulonglong_put_nbi_block))


@register
class _typing_qp_int8_put_nbi(ConcreteTemplate):
    key = globals()["qp_int8_put_nbi"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_int8_put_nbi, types.Function(_typing_qp_int8_put_nbi))


@register
class _typing_qp_int8_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_int8_put_nbi_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_int8_put_nbi_warp, types.Function(_typing_qp_int8_put_nbi_warp))


@register
class _typing_qp_int8_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_int8_put_nbi_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, int32, int32)]

register_global(qp_int8_put_nbi_block, types.Function(_typing_qp_int8_put_nbi_block))


@register
class _typing_qp_int16_put_nbi(ConcreteTemplate):
    key = globals()["qp_int16_put_nbi"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_int16_put_nbi, types.Function(_typing_qp_int16_put_nbi))


@register
class _typing_qp_int16_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_int16_put_nbi_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_int16_put_nbi_warp, types.Function(_typing_qp_int16_put_nbi_warp))


@register
class _typing_qp_int16_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_int16_put_nbi_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, int32, int32)]

register_global(qp_int16_put_nbi_block, types.Function(_typing_qp_int16_put_nbi_block))


@register
class _typing_qp_int32_put_nbi(ConcreteTemplate):
    key = globals()["qp_int32_put_nbi"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int32_put_nbi, types.Function(_typing_qp_int32_put_nbi))


@register
class _typing_qp_int32_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_int32_put_nbi_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int32_put_nbi_warp, types.Function(_typing_qp_int32_put_nbi_warp))


@register
class _typing_qp_int32_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_int32_put_nbi_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, int32, int32)]

register_global(qp_int32_put_nbi_block, types.Function(_typing_qp_int32_put_nbi_block))


@register
class _typing_qp_int64_put_nbi(ConcreteTemplate):
    key = globals()["qp_int64_put_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_int64_put_nbi, types.Function(_typing_qp_int64_put_nbi))


@register
class _typing_qp_int64_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_int64_put_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_int64_put_nbi_warp, types.Function(_typing_qp_int64_put_nbi_warp))


@register
class _typing_qp_int64_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_int64_put_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_int64_put_nbi_block, types.Function(_typing_qp_int64_put_nbi_block))


@register
class _typing_qp_uint8_put_nbi(ConcreteTemplate):
    key = globals()["qp_uint8_put_nbi"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uint8_put_nbi, types.Function(_typing_qp_uint8_put_nbi))


@register
class _typing_qp_uint8_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_uint8_put_nbi_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uint8_put_nbi_warp, types.Function(_typing_qp_uint8_put_nbi_warp))


@register
class _typing_qp_uint8_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_uint8_put_nbi_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, int32, int32)]

register_global(qp_uint8_put_nbi_block, types.Function(_typing_qp_uint8_put_nbi_block))


@register
class _typing_qp_uint16_put_nbi(ConcreteTemplate):
    key = globals()["qp_uint16_put_nbi"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_uint16_put_nbi, types.Function(_typing_qp_uint16_put_nbi))


@register
class _typing_qp_uint16_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_uint16_put_nbi_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_uint16_put_nbi_warp, types.Function(_typing_qp_uint16_put_nbi_warp))


@register
class _typing_qp_uint16_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_uint16_put_nbi_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, int32, int32)]

register_global(qp_uint16_put_nbi_block, types.Function(_typing_qp_uint16_put_nbi_block))


@register
class _typing_qp_uint32_put_nbi(ConcreteTemplate):
    key = globals()["qp_uint32_put_nbi"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint32_put_nbi, types.Function(_typing_qp_uint32_put_nbi))


@register
class _typing_qp_uint32_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_uint32_put_nbi_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint32_put_nbi_warp, types.Function(_typing_qp_uint32_put_nbi_warp))


@register
class _typing_qp_uint32_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_uint32_put_nbi_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, int32, int32)]

register_global(qp_uint32_put_nbi_block, types.Function(_typing_qp_uint32_put_nbi_block))


@register
class _typing_qp_uint64_put_nbi(ConcreteTemplate):
    key = globals()["qp_uint64_put_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_uint64_put_nbi, types.Function(_typing_qp_uint64_put_nbi))


@register
class _typing_qp_uint64_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_uint64_put_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_uint64_put_nbi_warp, types.Function(_typing_qp_uint64_put_nbi_warp))


@register
class _typing_qp_uint64_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_uint64_put_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_uint64_put_nbi_block, types.Function(_typing_qp_uint64_put_nbi_block))


@register
class _typing_qp_size_put_nbi(ConcreteTemplate):
    key = globals()["qp_size_put_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_size_put_nbi, types.Function(_typing_qp_size_put_nbi))


@register
class _typing_qp_size_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_size_put_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_size_put_nbi_warp, types.Function(_typing_qp_size_put_nbi_warp))


@register
class _typing_qp_size_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_size_put_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, int32, int32)]

register_global(qp_size_put_nbi_block, types.Function(_typing_qp_size_put_nbi_block))


@register
class _typing_qp_ptrdiff_put_nbi(ConcreteTemplate):
    key = globals()["qp_ptrdiff_put_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_ptrdiff_put_nbi, types.Function(_typing_qp_ptrdiff_put_nbi))


@register
class _typing_qp_ptrdiff_put_nbi_warp(ConcreteTemplate):
    key = globals()["qp_ptrdiff_put_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_ptrdiff_put_nbi_warp, types.Function(_typing_qp_ptrdiff_put_nbi_warp))


@register
class _typing_qp_ptrdiff_put_nbi_block(ConcreteTemplate):
    key = globals()["qp_ptrdiff_put_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, int32, int32)]

register_global(qp_ptrdiff_put_nbi_block, types.Function(_typing_qp_ptrdiff_put_nbi_block))


@register
class _typing_qp_bfloat16_p(ConcreteTemplate):
    key = globals()["qp_bfloat16_p"]
    cases = [signature(void, CPointer(bfloat16), bfloat16, int32, int32)]

register_global(qp_bfloat16_p, types.Function(_typing_qp_bfloat16_p))


@register
class _typing_qp_half_p(ConcreteTemplate):
    key = globals()["qp_half_p"]
    cases = [signature(void, CPointer(float16), float16, int32, int32)]

register_global(qp_half_p, types.Function(_typing_qp_half_p))


@register
class _typing_qp_float_p(ConcreteTemplate):
    key = globals()["qp_float_p"]
    cases = [signature(void, CPointer(float32), float32, int32, int32)]

register_global(qp_float_p, types.Function(_typing_qp_float_p))


@register
class _typing_qp_double_p(ConcreteTemplate):
    key = globals()["qp_double_p"]
    cases = [signature(void, CPointer(float64), float64, int32, int32)]

register_global(qp_double_p, types.Function(_typing_qp_double_p))


@register
class _typing_qp_char_p(ConcreteTemplate):
    key = globals()["qp_char_p"]
    cases = [signature(void, CPointer(int8), int8, int32, int32)]

register_global(qp_char_p, types.Function(_typing_qp_char_p))


@register
class _typing_qp_short_p(ConcreteTemplate):
    key = globals()["qp_short_p"]
    cases = [signature(void, CPointer(int16), int16, int32, int32)]

register_global(qp_short_p, types.Function(_typing_qp_short_p))


@register
class _typing_qp_schar_p(ConcreteTemplate):
    key = globals()["qp_schar_p"]
    cases = [signature(void, CPointer(int8), int8, int32, int32)]

register_global(qp_schar_p, types.Function(_typing_qp_schar_p))


@register
class _typing_qp_int_p(ConcreteTemplate):
    key = globals()["qp_int_p"]
    cases = [signature(void, CPointer(int32), int32, int32, int32)]

register_global(qp_int_p, types.Function(_typing_qp_int_p))


@register
class _typing_qp_long_p(ConcreteTemplate):
    key = globals()["qp_long_p"]
    cases = [signature(void, CPointer(int64), int64, int32, int32)]

register_global(qp_long_p, types.Function(_typing_qp_long_p))


@register
class _typing_qp_longlong_p(ConcreteTemplate):
    key = globals()["qp_longlong_p"]
    cases = [signature(void, CPointer(int64), int64, int32, int32)]

register_global(qp_longlong_p, types.Function(_typing_qp_longlong_p))


@register
class _typing_qp_uchar_p(ConcreteTemplate):
    key = globals()["qp_uchar_p"]
    cases = [signature(void, CPointer(uint8), uint8, int32, int32)]

register_global(qp_uchar_p, types.Function(_typing_qp_uchar_p))


@register
class _typing_qp_ushort_p(ConcreteTemplate):
    key = globals()["qp_ushort_p"]
    cases = [signature(void, CPointer(uint16), uint16, int32, int32)]

register_global(qp_ushort_p, types.Function(_typing_qp_ushort_p))


@register
class _typing_qp_uint_p(ConcreteTemplate):
    key = globals()["qp_uint_p"]
    cases = [signature(void, CPointer(uint32), uint32, int32, int32)]

register_global(qp_uint_p, types.Function(_typing_qp_uint_p))


@register
class _typing_qp_ulong_p(ConcreteTemplate):
    key = globals()["qp_ulong_p"]
    cases = [signature(void, CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulong_p, types.Function(_typing_qp_ulong_p))


@register
class _typing_qp_ulonglong_p(ConcreteTemplate):
    key = globals()["qp_ulonglong_p"]
    cases = [signature(void, CPointer(uint64), uint64, int32, int32)]

register_global(qp_ulonglong_p, types.Function(_typing_qp_ulonglong_p))


@register
class _typing_qp_int8_p(ConcreteTemplate):
    key = globals()["qp_int8_p"]
    cases = [signature(void, CPointer(int8), int8, int32, int32)]

register_global(qp_int8_p, types.Function(_typing_qp_int8_p))


@register
class _typing_qp_int16_p(ConcreteTemplate):
    key = globals()["qp_int16_p"]
    cases = [signature(void, CPointer(int16), int16, int32, int32)]

register_global(qp_int16_p, types.Function(_typing_qp_int16_p))


@register
class _typing_qp_int32_p(ConcreteTemplate):
    key = globals()["qp_int32_p"]
    cases = [signature(void, CPointer(int32), int32, int32, int32)]

register_global(qp_int32_p, types.Function(_typing_qp_int32_p))


@register
class _typing_qp_int64_p(ConcreteTemplate):
    key = globals()["qp_int64_p"]
    cases = [signature(void, CPointer(int64), int64, int32, int32)]

register_global(qp_int64_p, types.Function(_typing_qp_int64_p))


@register
class _typing_qp_uint8_p(ConcreteTemplate):
    key = globals()["qp_uint8_p"]
    cases = [signature(void, CPointer(uint8), uint8, int32, int32)]

register_global(qp_uint8_p, types.Function(_typing_qp_uint8_p))


@register
class _typing_qp_uint16_p(ConcreteTemplate):
    key = globals()["qp_uint16_p"]
    cases = [signature(void, CPointer(uint16), uint16, int32, int32)]

register_global(qp_uint16_p, types.Function(_typing_qp_uint16_p))


@register
class _typing_qp_uint32_p(ConcreteTemplate):
    key = globals()["qp_uint32_p"]
    cases = [signature(void, CPointer(uint32), uint32, int32, int32)]

register_global(qp_uint32_p, types.Function(_typing_qp_uint32_p))


@register
class _typing_qp_uint64_p(ConcreteTemplate):
    key = globals()["qp_uint64_p"]
    cases = [signature(void, CPointer(uint64), uint64, int32, int32)]

register_global(qp_uint64_p, types.Function(_typing_qp_uint64_p))


@register
class _typing_qp_size_p(ConcreteTemplate):
    key = globals()["qp_size_p"]
    cases = [signature(void, CPointer(uint64), uint64, int32, int32)]

register_global(qp_size_p, types.Function(_typing_qp_size_p))


@register
class _typing_qp_ptrdiff_p(ConcreteTemplate):
    key = globals()["qp_ptrdiff_p"]
    cases = [signature(void, CPointer(int64), int64, int32, int32)]

register_global(qp_ptrdiff_p, types.Function(_typing_qp_ptrdiff_p))


@register
class _typing_qp_bfloat16_g(ConcreteTemplate):
    key = globals()["qp_bfloat16_g"]
    cases = [signature(bfloat16, CPointer(bfloat16), int32, int32)]

register_global(qp_bfloat16_g, types.Function(_typing_qp_bfloat16_g))


@register
class _typing_qp_half_g(ConcreteTemplate):
    key = globals()["qp_half_g"]
    cases = [signature(float16, CPointer(float16), int32, int32)]

register_global(qp_half_g, types.Function(_typing_qp_half_g))


@register
class _typing_qp_float_g(ConcreteTemplate):
    key = globals()["qp_float_g"]
    cases = [signature(float32, CPointer(float32), int32, int32)]

register_global(qp_float_g, types.Function(_typing_qp_float_g))


@register
class _typing_qp_double_g(ConcreteTemplate):
    key = globals()["qp_double_g"]
    cases = [signature(float64, CPointer(float64), int32, int32)]

register_global(qp_double_g, types.Function(_typing_qp_double_g))


@register
class _typing_qp_char_g(ConcreteTemplate):
    key = globals()["qp_char_g"]
    cases = [signature(int8, CPointer(int8), int32, int32)]

register_global(qp_char_g, types.Function(_typing_qp_char_g))


@register
class _typing_qp_short_g(ConcreteTemplate):
    key = globals()["qp_short_g"]
    cases = [signature(int16, CPointer(int16), int32, int32)]

register_global(qp_short_g, types.Function(_typing_qp_short_g))


@register
class _typing_qp_schar_g(ConcreteTemplate):
    key = globals()["qp_schar_g"]
    cases = [signature(int8, CPointer(int8), int32, int32)]

register_global(qp_schar_g, types.Function(_typing_qp_schar_g))


@register
class _typing_qp_int_g(ConcreteTemplate):
    key = globals()["qp_int_g"]
    cases = [signature(int32, CPointer(int32), int32, int32)]

register_global(qp_int_g, types.Function(_typing_qp_int_g))


@register
class _typing_qp_long_g(ConcreteTemplate):
    key = globals()["qp_long_g"]
    cases = [signature(int64, CPointer(int64), int32, int32)]

register_global(qp_long_g, types.Function(_typing_qp_long_g))


@register
class _typing_qp_longlong_g(ConcreteTemplate):
    key = globals()["qp_longlong_g"]
    cases = [signature(int64, CPointer(int64), int32, int32)]

register_global(qp_longlong_g, types.Function(_typing_qp_longlong_g))


@register
class _typing_qp_uchar_g(ConcreteTemplate):
    key = globals()["qp_uchar_g"]
    cases = [signature(uint8, CPointer(uint8), int32, int32)]

register_global(qp_uchar_g, types.Function(_typing_qp_uchar_g))


@register
class _typing_qp_ushort_g(ConcreteTemplate):
    key = globals()["qp_ushort_g"]
    cases = [signature(uint16, CPointer(uint16), int32, int32)]

register_global(qp_ushort_g, types.Function(_typing_qp_ushort_g))


@register
class _typing_qp_uint_g(ConcreteTemplate):
    key = globals()["qp_uint_g"]
    cases = [signature(uint32, CPointer(uint32), int32, int32)]

register_global(qp_uint_g, types.Function(_typing_qp_uint_g))


@register
class _typing_qp_ulong_g(ConcreteTemplate):
    key = globals()["qp_ulong_g"]
    cases = [signature(uint64, CPointer(uint64), int32, int32)]

register_global(qp_ulong_g, types.Function(_typing_qp_ulong_g))


@register
class _typing_qp_ulonglong_g(ConcreteTemplate):
    key = globals()["qp_ulonglong_g"]
    cases = [signature(uint64, CPointer(uint64), int32, int32)]

register_global(qp_ulonglong_g, types.Function(_typing_qp_ulonglong_g))


@register
class _typing_qp_int8_g(ConcreteTemplate):
    key = globals()["qp_int8_g"]
    cases = [signature(int8, CPointer(int8), int32, int32)]

register_global(qp_int8_g, types.Function(_typing_qp_int8_g))


@register
class _typing_qp_int16_g(ConcreteTemplate):
    key = globals()["qp_int16_g"]
    cases = [signature(int16, CPointer(int16), int32, int32)]

register_global(qp_int16_g, types.Function(_typing_qp_int16_g))


@register
class _typing_qp_int32_g(ConcreteTemplate):
    key = globals()["qp_int32_g"]
    cases = [signature(int32, CPointer(int32), int32, int32)]

register_global(qp_int32_g, types.Function(_typing_qp_int32_g))


@register
class _typing_qp_int64_g(ConcreteTemplate):
    key = globals()["qp_int64_g"]
    cases = [signature(int64, CPointer(int64), int32, int32)]

register_global(qp_int64_g, types.Function(_typing_qp_int64_g))


@register
class _typing_qp_uint8_g(ConcreteTemplate):
    key = globals()["qp_uint8_g"]
    cases = [signature(uint8, CPointer(uint8), int32, int32)]

register_global(qp_uint8_g, types.Function(_typing_qp_uint8_g))


@register
class _typing_qp_uint16_g(ConcreteTemplate):
    key = globals()["qp_uint16_g"]
    cases = [signature(uint16, CPointer(uint16), int32, int32)]

register_global(qp_uint16_g, types.Function(_typing_qp_uint16_g))


@register
class _typing_qp_uint32_g(ConcreteTemplate):
    key = globals()["qp_uint32_g"]
    cases = [signature(uint32, CPointer(uint32), int32, int32)]

register_global(qp_uint32_g, types.Function(_typing_qp_uint32_g))


@register
class _typing_qp_uint64_g(ConcreteTemplate):
    key = globals()["qp_uint64_g"]
    cases = [signature(uint64, CPointer(uint64), int32, int32)]

register_global(qp_uint64_g, types.Function(_typing_qp_uint64_g))


@register
class _typing_qp_size_g(ConcreteTemplate):
    key = globals()["qp_size_g"]
    cases = [signature(uint64, CPointer(uint64), int32, int32)]

register_global(qp_size_g, types.Function(_typing_qp_size_g))


@register
class _typing_qp_ptrdiff_g(ConcreteTemplate):
    key = globals()["qp_ptrdiff_g"]
    cases = [signature(int64, CPointer(int64), int32, int32)]

register_global(qp_ptrdiff_g, types.Function(_typing_qp_ptrdiff_g))


@register
class _typing_qp_signal_op(ConcreteTemplate):
    key = globals()["qp_signal_op"]
    cases = [signature(void, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_signal_op, types.Function(_typing_qp_signal_op))


@register
class _typing_qp_bfloat16_put_signal(ConcreteTemplate):
    key = globals()["qp_bfloat16_put_signal"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_bfloat16_put_signal, types.Function(_typing_qp_bfloat16_put_signal))


@register
class _typing_qp_bfloat16_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_bfloat16_put_signal_warp"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_bfloat16_put_signal_warp, types.Function(_typing_qp_bfloat16_put_signal_warp))


@register
class _typing_qp_bfloat16_put_signal_block(ConcreteTemplate):
    key = globals()["qp_bfloat16_put_signal_block"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_bfloat16_put_signal_block, types.Function(_typing_qp_bfloat16_put_signal_block))


@register
class _typing_qp_half_put_signal(ConcreteTemplate):
    key = globals()["qp_half_put_signal"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_half_put_signal, types.Function(_typing_qp_half_put_signal))


@register
class _typing_qp_half_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_half_put_signal_warp"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_half_put_signal_warp, types.Function(_typing_qp_half_put_signal_warp))


@register
class _typing_qp_half_put_signal_block(ConcreteTemplate):
    key = globals()["qp_half_put_signal_block"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_half_put_signal_block, types.Function(_typing_qp_half_put_signal_block))


@register
class _typing_qp_float_put_signal(ConcreteTemplate):
    key = globals()["qp_float_put_signal"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_float_put_signal, types.Function(_typing_qp_float_put_signal))


@register
class _typing_qp_float_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_float_put_signal_warp"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_float_put_signal_warp, types.Function(_typing_qp_float_put_signal_warp))


@register
class _typing_qp_float_put_signal_block(ConcreteTemplate):
    key = globals()["qp_float_put_signal_block"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_float_put_signal_block, types.Function(_typing_qp_float_put_signal_block))


@register
class _typing_qp_double_put_signal(ConcreteTemplate):
    key = globals()["qp_double_put_signal"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_double_put_signal, types.Function(_typing_qp_double_put_signal))


@register
class _typing_qp_double_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_double_put_signal_warp"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_double_put_signal_warp, types.Function(_typing_qp_double_put_signal_warp))


@register
class _typing_qp_double_put_signal_block(ConcreteTemplate):
    key = globals()["qp_double_put_signal_block"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_double_put_signal_block, types.Function(_typing_qp_double_put_signal_block))


@register
class _typing_qp_char_put_signal(ConcreteTemplate):
    key = globals()["qp_char_put_signal"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_char_put_signal, types.Function(_typing_qp_char_put_signal))


@register
class _typing_qp_char_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_char_put_signal_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_char_put_signal_warp, types.Function(_typing_qp_char_put_signal_warp))


@register
class _typing_qp_char_put_signal_block(ConcreteTemplate):
    key = globals()["qp_char_put_signal_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_char_put_signal_block, types.Function(_typing_qp_char_put_signal_block))


@register
class _typing_qp_short_put_signal(ConcreteTemplate):
    key = globals()["qp_short_put_signal"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_short_put_signal, types.Function(_typing_qp_short_put_signal))


@register
class _typing_qp_short_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_short_put_signal_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_short_put_signal_warp, types.Function(_typing_qp_short_put_signal_warp))


@register
class _typing_qp_short_put_signal_block(ConcreteTemplate):
    key = globals()["qp_short_put_signal_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_short_put_signal_block, types.Function(_typing_qp_short_put_signal_block))


@register
class _typing_qp_schar_put_signal(ConcreteTemplate):
    key = globals()["qp_schar_put_signal"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_schar_put_signal, types.Function(_typing_qp_schar_put_signal))


@register
class _typing_qp_schar_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_schar_put_signal_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_schar_put_signal_warp, types.Function(_typing_qp_schar_put_signal_warp))


@register
class _typing_qp_schar_put_signal_block(ConcreteTemplate):
    key = globals()["qp_schar_put_signal_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_schar_put_signal_block, types.Function(_typing_qp_schar_put_signal_block))


@register
class _typing_qp_int_put_signal(ConcreteTemplate):
    key = globals()["qp_int_put_signal"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int_put_signal, types.Function(_typing_qp_int_put_signal))


@register
class _typing_qp_int_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_int_put_signal_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int_put_signal_warp, types.Function(_typing_qp_int_put_signal_warp))


@register
class _typing_qp_int_put_signal_block(ConcreteTemplate):
    key = globals()["qp_int_put_signal_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int_put_signal_block, types.Function(_typing_qp_int_put_signal_block))


@register
class _typing_qp_long_put_signal(ConcreteTemplate):
    key = globals()["qp_long_put_signal"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_long_put_signal, types.Function(_typing_qp_long_put_signal))


@register
class _typing_qp_long_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_long_put_signal_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_long_put_signal_warp, types.Function(_typing_qp_long_put_signal_warp))


@register
class _typing_qp_long_put_signal_block(ConcreteTemplate):
    key = globals()["qp_long_put_signal_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_long_put_signal_block, types.Function(_typing_qp_long_put_signal_block))


@register
class _typing_qp_longlong_put_signal(ConcreteTemplate):
    key = globals()["qp_longlong_put_signal"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_longlong_put_signal, types.Function(_typing_qp_longlong_put_signal))


@register
class _typing_qp_longlong_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_longlong_put_signal_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_longlong_put_signal_warp, types.Function(_typing_qp_longlong_put_signal_warp))


@register
class _typing_qp_longlong_put_signal_block(ConcreteTemplate):
    key = globals()["qp_longlong_put_signal_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_longlong_put_signal_block, types.Function(_typing_qp_longlong_put_signal_block))


@register
class _typing_qp_uchar_put_signal(ConcreteTemplate):
    key = globals()["qp_uchar_put_signal"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uchar_put_signal, types.Function(_typing_qp_uchar_put_signal))


@register
class _typing_qp_uchar_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_uchar_put_signal_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uchar_put_signal_warp, types.Function(_typing_qp_uchar_put_signal_warp))


@register
class _typing_qp_uchar_put_signal_block(ConcreteTemplate):
    key = globals()["qp_uchar_put_signal_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uchar_put_signal_block, types.Function(_typing_qp_uchar_put_signal_block))


@register
class _typing_qp_ushort_put_signal(ConcreteTemplate):
    key = globals()["qp_ushort_put_signal"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ushort_put_signal, types.Function(_typing_qp_ushort_put_signal))


@register
class _typing_qp_ushort_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_ushort_put_signal_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ushort_put_signal_warp, types.Function(_typing_qp_ushort_put_signal_warp))


@register
class _typing_qp_ushort_put_signal_block(ConcreteTemplate):
    key = globals()["qp_ushort_put_signal_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ushort_put_signal_block, types.Function(_typing_qp_ushort_put_signal_block))


@register
class _typing_qp_uint_put_signal(ConcreteTemplate):
    key = globals()["qp_uint_put_signal"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint_put_signal, types.Function(_typing_qp_uint_put_signal))


@register
class _typing_qp_uint_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_uint_put_signal_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint_put_signal_warp, types.Function(_typing_qp_uint_put_signal_warp))


@register
class _typing_qp_uint_put_signal_block(ConcreteTemplate):
    key = globals()["qp_uint_put_signal_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint_put_signal_block, types.Function(_typing_qp_uint_put_signal_block))


@register
class _typing_qp_ulong_put_signal(ConcreteTemplate):
    key = globals()["qp_ulong_put_signal"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ulong_put_signal, types.Function(_typing_qp_ulong_put_signal))


@register
class _typing_qp_ulong_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_ulong_put_signal_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ulong_put_signal_warp, types.Function(_typing_qp_ulong_put_signal_warp))


@register
class _typing_qp_ulong_put_signal_block(ConcreteTemplate):
    key = globals()["qp_ulong_put_signal_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ulong_put_signal_block, types.Function(_typing_qp_ulong_put_signal_block))


@register
class _typing_qp_ulonglong_put_signal(ConcreteTemplate):
    key = globals()["qp_ulonglong_put_signal"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ulonglong_put_signal, types.Function(_typing_qp_ulonglong_put_signal))


@register
class _typing_qp_ulonglong_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_ulonglong_put_signal_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ulonglong_put_signal_warp, types.Function(_typing_qp_ulonglong_put_signal_warp))


@register
class _typing_qp_ulonglong_put_signal_block(ConcreteTemplate):
    key = globals()["qp_ulonglong_put_signal_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ulonglong_put_signal_block, types.Function(_typing_qp_ulonglong_put_signal_block))


@register
class _typing_qp_int8_put_signal(ConcreteTemplate):
    key = globals()["qp_int8_put_signal"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int8_put_signal, types.Function(_typing_qp_int8_put_signal))


@register
class _typing_qp_int8_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_int8_put_signal_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int8_put_signal_warp, types.Function(_typing_qp_int8_put_signal_warp))


@register
class _typing_qp_int8_put_signal_block(ConcreteTemplate):
    key = globals()["qp_int8_put_signal_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int8_put_signal_block, types.Function(_typing_qp_int8_put_signal_block))


@register
class _typing_qp_int16_put_signal(ConcreteTemplate):
    key = globals()["qp_int16_put_signal"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int16_put_signal, types.Function(_typing_qp_int16_put_signal))


@register
class _typing_qp_int16_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_int16_put_signal_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int16_put_signal_warp, types.Function(_typing_qp_int16_put_signal_warp))


@register
class _typing_qp_int16_put_signal_block(ConcreteTemplate):
    key = globals()["qp_int16_put_signal_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int16_put_signal_block, types.Function(_typing_qp_int16_put_signal_block))


@register
class _typing_qp_int32_put_signal(ConcreteTemplate):
    key = globals()["qp_int32_put_signal"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int32_put_signal, types.Function(_typing_qp_int32_put_signal))


@register
class _typing_qp_int32_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_int32_put_signal_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int32_put_signal_warp, types.Function(_typing_qp_int32_put_signal_warp))


@register
class _typing_qp_int32_put_signal_block(ConcreteTemplate):
    key = globals()["qp_int32_put_signal_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int32_put_signal_block, types.Function(_typing_qp_int32_put_signal_block))


@register
class _typing_qp_int64_put_signal(ConcreteTemplate):
    key = globals()["qp_int64_put_signal"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int64_put_signal, types.Function(_typing_qp_int64_put_signal))


@register
class _typing_qp_int64_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_int64_put_signal_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int64_put_signal_warp, types.Function(_typing_qp_int64_put_signal_warp))


@register
class _typing_qp_int64_put_signal_block(ConcreteTemplate):
    key = globals()["qp_int64_put_signal_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int64_put_signal_block, types.Function(_typing_qp_int64_put_signal_block))


@register
class _typing_qp_uint8_put_signal(ConcreteTemplate):
    key = globals()["qp_uint8_put_signal"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint8_put_signal, types.Function(_typing_qp_uint8_put_signal))


@register
class _typing_qp_uint8_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_uint8_put_signal_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint8_put_signal_warp, types.Function(_typing_qp_uint8_put_signal_warp))


@register
class _typing_qp_uint8_put_signal_block(ConcreteTemplate):
    key = globals()["qp_uint8_put_signal_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint8_put_signal_block, types.Function(_typing_qp_uint8_put_signal_block))


@register
class _typing_qp_uint16_put_signal(ConcreteTemplate):
    key = globals()["qp_uint16_put_signal"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint16_put_signal, types.Function(_typing_qp_uint16_put_signal))


@register
class _typing_qp_uint16_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_uint16_put_signal_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint16_put_signal_warp, types.Function(_typing_qp_uint16_put_signal_warp))


@register
class _typing_qp_uint16_put_signal_block(ConcreteTemplate):
    key = globals()["qp_uint16_put_signal_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint16_put_signal_block, types.Function(_typing_qp_uint16_put_signal_block))


@register
class _typing_qp_uint32_put_signal(ConcreteTemplate):
    key = globals()["qp_uint32_put_signal"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint32_put_signal, types.Function(_typing_qp_uint32_put_signal))


@register
class _typing_qp_uint32_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_uint32_put_signal_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint32_put_signal_warp, types.Function(_typing_qp_uint32_put_signal_warp))


@register
class _typing_qp_uint32_put_signal_block(ConcreteTemplate):
    key = globals()["qp_uint32_put_signal_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint32_put_signal_block, types.Function(_typing_qp_uint32_put_signal_block))


@register
class _typing_qp_uint64_put_signal(ConcreteTemplate):
    key = globals()["qp_uint64_put_signal"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint64_put_signal, types.Function(_typing_qp_uint64_put_signal))


@register
class _typing_qp_uint64_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_uint64_put_signal_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint64_put_signal_warp, types.Function(_typing_qp_uint64_put_signal_warp))


@register
class _typing_qp_uint64_put_signal_block(ConcreteTemplate):
    key = globals()["qp_uint64_put_signal_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint64_put_signal_block, types.Function(_typing_qp_uint64_put_signal_block))


@register
class _typing_qp_size_put_signal(ConcreteTemplate):
    key = globals()["qp_size_put_signal"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_size_put_signal, types.Function(_typing_qp_size_put_signal))


@register
class _typing_qp_size_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_size_put_signal_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_size_put_signal_warp, types.Function(_typing_qp_size_put_signal_warp))


@register
class _typing_qp_size_put_signal_block(ConcreteTemplate):
    key = globals()["qp_size_put_signal_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_size_put_signal_block, types.Function(_typing_qp_size_put_signal_block))


@register
class _typing_qp_ptrdiff_put_signal(ConcreteTemplate):
    key = globals()["qp_ptrdiff_put_signal"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ptrdiff_put_signal, types.Function(_typing_qp_ptrdiff_put_signal))


@register
class _typing_qp_ptrdiff_put_signal_warp(ConcreteTemplate):
    key = globals()["qp_ptrdiff_put_signal_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ptrdiff_put_signal_warp, types.Function(_typing_qp_ptrdiff_put_signal_warp))


@register
class _typing_qp_ptrdiff_put_signal_block(ConcreteTemplate):
    key = globals()["qp_ptrdiff_put_signal_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ptrdiff_put_signal_block, types.Function(_typing_qp_ptrdiff_put_signal_block))


@register
class _typing_qp_bfloat16_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_bfloat16_put_signal_nbi"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_bfloat16_put_signal_nbi, types.Function(_typing_qp_bfloat16_put_signal_nbi))


@register
class _typing_qp_bfloat16_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_bfloat16_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_bfloat16_put_signal_nbi_warp, types.Function(_typing_qp_bfloat16_put_signal_nbi_warp))


@register
class _typing_qp_bfloat16_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_bfloat16_put_signal_nbi_block"]
    cases = [signature(void, CPointer(bfloat16), CPointer(bfloat16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_bfloat16_put_signal_nbi_block, types.Function(_typing_qp_bfloat16_put_signal_nbi_block))


@register
class _typing_qp_half_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_half_put_signal_nbi"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_half_put_signal_nbi, types.Function(_typing_qp_half_put_signal_nbi))


@register
class _typing_qp_half_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_half_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_half_put_signal_nbi_warp, types.Function(_typing_qp_half_put_signal_nbi_warp))


@register
class _typing_qp_half_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_half_put_signal_nbi_block"]
    cases = [signature(void, CPointer(float16), CPointer(float16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_half_put_signal_nbi_block, types.Function(_typing_qp_half_put_signal_nbi_block))


@register
class _typing_qp_float_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_float_put_signal_nbi"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_float_put_signal_nbi, types.Function(_typing_qp_float_put_signal_nbi))


@register
class _typing_qp_float_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_float_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_float_put_signal_nbi_warp, types.Function(_typing_qp_float_put_signal_nbi_warp))


@register
class _typing_qp_float_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_float_put_signal_nbi_block"]
    cases = [signature(void, CPointer(float32), CPointer(float32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_float_put_signal_nbi_block, types.Function(_typing_qp_float_put_signal_nbi_block))


@register
class _typing_qp_double_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_double_put_signal_nbi"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_double_put_signal_nbi, types.Function(_typing_qp_double_put_signal_nbi))


@register
class _typing_qp_double_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_double_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_double_put_signal_nbi_warp, types.Function(_typing_qp_double_put_signal_nbi_warp))


@register
class _typing_qp_double_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_double_put_signal_nbi_block"]
    cases = [signature(void, CPointer(float64), CPointer(float64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_double_put_signal_nbi_block, types.Function(_typing_qp_double_put_signal_nbi_block))


@register
class _typing_qp_char_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_char_put_signal_nbi"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_char_put_signal_nbi, types.Function(_typing_qp_char_put_signal_nbi))


@register
class _typing_qp_char_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_char_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_char_put_signal_nbi_warp, types.Function(_typing_qp_char_put_signal_nbi_warp))


@register
class _typing_qp_char_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_char_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_char_put_signal_nbi_block, types.Function(_typing_qp_char_put_signal_nbi_block))


@register
class _typing_qp_short_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_short_put_signal_nbi"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_short_put_signal_nbi, types.Function(_typing_qp_short_put_signal_nbi))


@register
class _typing_qp_short_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_short_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_short_put_signal_nbi_warp, types.Function(_typing_qp_short_put_signal_nbi_warp))


@register
class _typing_qp_short_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_short_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_short_put_signal_nbi_block, types.Function(_typing_qp_short_put_signal_nbi_block))


@register
class _typing_qp_schar_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_schar_put_signal_nbi"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_schar_put_signal_nbi, types.Function(_typing_qp_schar_put_signal_nbi))


@register
class _typing_qp_schar_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_schar_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_schar_put_signal_nbi_warp, types.Function(_typing_qp_schar_put_signal_nbi_warp))


@register
class _typing_qp_schar_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_schar_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_schar_put_signal_nbi_block, types.Function(_typing_qp_schar_put_signal_nbi_block))


@register
class _typing_qp_int_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_int_put_signal_nbi"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int_put_signal_nbi, types.Function(_typing_qp_int_put_signal_nbi))


@register
class _typing_qp_int_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_int_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int_put_signal_nbi_warp, types.Function(_typing_qp_int_put_signal_nbi_warp))


@register
class _typing_qp_int_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_int_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int_put_signal_nbi_block, types.Function(_typing_qp_int_put_signal_nbi_block))


@register
class _typing_qp_long_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_long_put_signal_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_long_put_signal_nbi, types.Function(_typing_qp_long_put_signal_nbi))


@register
class _typing_qp_long_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_long_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_long_put_signal_nbi_warp, types.Function(_typing_qp_long_put_signal_nbi_warp))


@register
class _typing_qp_long_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_long_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_long_put_signal_nbi_block, types.Function(_typing_qp_long_put_signal_nbi_block))


@register
class _typing_qp_longlong_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_longlong_put_signal_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_longlong_put_signal_nbi, types.Function(_typing_qp_longlong_put_signal_nbi))


@register
class _typing_qp_longlong_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_longlong_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_longlong_put_signal_nbi_warp, types.Function(_typing_qp_longlong_put_signal_nbi_warp))


@register
class _typing_qp_longlong_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_longlong_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_longlong_put_signal_nbi_block, types.Function(_typing_qp_longlong_put_signal_nbi_block))


@register
class _typing_qp_uchar_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_uchar_put_signal_nbi"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uchar_put_signal_nbi, types.Function(_typing_qp_uchar_put_signal_nbi))


@register
class _typing_qp_uchar_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_uchar_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uchar_put_signal_nbi_warp, types.Function(_typing_qp_uchar_put_signal_nbi_warp))


@register
class _typing_qp_uchar_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_uchar_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uchar_put_signal_nbi_block, types.Function(_typing_qp_uchar_put_signal_nbi_block))


@register
class _typing_qp_ushort_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_ushort_put_signal_nbi"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ushort_put_signal_nbi, types.Function(_typing_qp_ushort_put_signal_nbi))


@register
class _typing_qp_ushort_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_ushort_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ushort_put_signal_nbi_warp, types.Function(_typing_qp_ushort_put_signal_nbi_warp))


@register
class _typing_qp_ushort_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_ushort_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ushort_put_signal_nbi_block, types.Function(_typing_qp_ushort_put_signal_nbi_block))


@register
class _typing_qp_uint_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_uint_put_signal_nbi"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint_put_signal_nbi, types.Function(_typing_qp_uint_put_signal_nbi))


@register
class _typing_qp_uint_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_uint_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint_put_signal_nbi_warp, types.Function(_typing_qp_uint_put_signal_nbi_warp))


@register
class _typing_qp_uint_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_uint_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint_put_signal_nbi_block, types.Function(_typing_qp_uint_put_signal_nbi_block))


@register
class _typing_qp_ulong_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_ulong_put_signal_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ulong_put_signal_nbi, types.Function(_typing_qp_ulong_put_signal_nbi))


@register
class _typing_qp_ulong_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_ulong_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ulong_put_signal_nbi_warp, types.Function(_typing_qp_ulong_put_signal_nbi_warp))


@register
class _typing_qp_ulong_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_ulong_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ulong_put_signal_nbi_block, types.Function(_typing_qp_ulong_put_signal_nbi_block))


@register
class _typing_qp_ulonglong_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_ulonglong_put_signal_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ulonglong_put_signal_nbi, types.Function(_typing_qp_ulonglong_put_signal_nbi))


@register
class _typing_qp_ulonglong_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_ulonglong_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ulonglong_put_signal_nbi_warp, types.Function(_typing_qp_ulonglong_put_signal_nbi_warp))


@register
class _typing_qp_ulonglong_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_ulonglong_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ulonglong_put_signal_nbi_block, types.Function(_typing_qp_ulonglong_put_signal_nbi_block))


@register
class _typing_qp_int8_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_int8_put_signal_nbi"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int8_put_signal_nbi, types.Function(_typing_qp_int8_put_signal_nbi))


@register
class _typing_qp_int8_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_int8_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int8_put_signal_nbi_warp, types.Function(_typing_qp_int8_put_signal_nbi_warp))


@register
class _typing_qp_int8_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_int8_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int8), CPointer(int8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int8_put_signal_nbi_block, types.Function(_typing_qp_int8_put_signal_nbi_block))


@register
class _typing_qp_int16_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_int16_put_signal_nbi"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int16_put_signal_nbi, types.Function(_typing_qp_int16_put_signal_nbi))


@register
class _typing_qp_int16_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_int16_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int16_put_signal_nbi_warp, types.Function(_typing_qp_int16_put_signal_nbi_warp))


@register
class _typing_qp_int16_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_int16_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int16), CPointer(int16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int16_put_signal_nbi_block, types.Function(_typing_qp_int16_put_signal_nbi_block))


@register
class _typing_qp_int32_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_int32_put_signal_nbi"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int32_put_signal_nbi, types.Function(_typing_qp_int32_put_signal_nbi))


@register
class _typing_qp_int32_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_int32_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int32_put_signal_nbi_warp, types.Function(_typing_qp_int32_put_signal_nbi_warp))


@register
class _typing_qp_int32_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_int32_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int32), CPointer(int32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int32_put_signal_nbi_block, types.Function(_typing_qp_int32_put_signal_nbi_block))


@register
class _typing_qp_int64_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_int64_put_signal_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int64_put_signal_nbi, types.Function(_typing_qp_int64_put_signal_nbi))


@register
class _typing_qp_int64_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_int64_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int64_put_signal_nbi_warp, types.Function(_typing_qp_int64_put_signal_nbi_warp))


@register
class _typing_qp_int64_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_int64_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_int64_put_signal_nbi_block, types.Function(_typing_qp_int64_put_signal_nbi_block))


@register
class _typing_qp_uint8_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_uint8_put_signal_nbi"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint8_put_signal_nbi, types.Function(_typing_qp_uint8_put_signal_nbi))


@register
class _typing_qp_uint8_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_uint8_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint8_put_signal_nbi_warp, types.Function(_typing_qp_uint8_put_signal_nbi_warp))


@register
class _typing_qp_uint8_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_uint8_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint8), CPointer(uint8), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint8_put_signal_nbi_block, types.Function(_typing_qp_uint8_put_signal_nbi_block))


@register
class _typing_qp_uint16_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_uint16_put_signal_nbi"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint16_put_signal_nbi, types.Function(_typing_qp_uint16_put_signal_nbi))


@register
class _typing_qp_uint16_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_uint16_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint16_put_signal_nbi_warp, types.Function(_typing_qp_uint16_put_signal_nbi_warp))


@register
class _typing_qp_uint16_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_uint16_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint16), CPointer(uint16), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint16_put_signal_nbi_block, types.Function(_typing_qp_uint16_put_signal_nbi_block))


@register
class _typing_qp_uint32_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_uint32_put_signal_nbi"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint32_put_signal_nbi, types.Function(_typing_qp_uint32_put_signal_nbi))


@register
class _typing_qp_uint32_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_uint32_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint32_put_signal_nbi_warp, types.Function(_typing_qp_uint32_put_signal_nbi_warp))


@register
class _typing_qp_uint32_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_uint32_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint32), CPointer(uint32), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint32_put_signal_nbi_block, types.Function(_typing_qp_uint32_put_signal_nbi_block))


@register
class _typing_qp_uint64_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_uint64_put_signal_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint64_put_signal_nbi, types.Function(_typing_qp_uint64_put_signal_nbi))


@register
class _typing_qp_uint64_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_uint64_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint64_put_signal_nbi_warp, types.Function(_typing_qp_uint64_put_signal_nbi_warp))


@register
class _typing_qp_uint64_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_uint64_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_uint64_put_signal_nbi_block, types.Function(_typing_qp_uint64_put_signal_nbi_block))


@register
class _typing_qp_size_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_size_put_signal_nbi"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_size_put_signal_nbi, types.Function(_typing_qp_size_put_signal_nbi))


@register
class _typing_qp_size_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_size_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_size_put_signal_nbi_warp, types.Function(_typing_qp_size_put_signal_nbi_warp))


@register
class _typing_qp_size_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_size_put_signal_nbi_block"]
    cases = [signature(void, CPointer(uint64), CPointer(uint64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_size_put_signal_nbi_block, types.Function(_typing_qp_size_put_signal_nbi_block))


@register
class _typing_qp_ptrdiff_put_signal_nbi(ConcreteTemplate):
    key = globals()["qp_ptrdiff_put_signal_nbi"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ptrdiff_put_signal_nbi, types.Function(_typing_qp_ptrdiff_put_signal_nbi))


@register
class _typing_qp_ptrdiff_put_signal_nbi_warp(ConcreteTemplate):
    key = globals()["qp_ptrdiff_put_signal_nbi_warp"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ptrdiff_put_signal_nbi_warp, types.Function(_typing_qp_ptrdiff_put_signal_nbi_warp))


@register
class _typing_qp_ptrdiff_put_signal_nbi_block(ConcreteTemplate):
    key = globals()["qp_ptrdiff_put_signal_nbi_block"]
    cases = [signature(void, CPointer(int64), CPointer(int64), uint64, CPointer(uint64), uint64, int32, int32, int32)]

register_global(qp_ptrdiff_put_signal_nbi_block, types.Function(_typing_qp_ptrdiff_put_signal_nbi_block))


@register
class _typing_qp_quiet(ConcreteTemplate):
    key = globals()["qp_quiet"]
    cases = [signature(void, int32, CPointer(int32), int32)]

register_global(qp_quiet, types.Function(_typing_qp_quiet))


@register
class _typing_qp_quiet_warp(ConcreteTemplate):
    key = globals()["qp_quiet_warp"]
    cases = [signature(void, int32, CPointer(int32), int32)]

register_global(qp_quiet_warp, types.Function(_typing_qp_quiet_warp))


@register
class _typing_qp_quiet_block(ConcreteTemplate):
    key = globals()["qp_quiet_block"]
    cases = [signature(void, int32, CPointer(int32), int32)]

register_global(qp_quiet_block, types.Function(_typing_qp_quiet_block))


@register
class _typing_qp_fence(ConcreteTemplate):
    key = globals()["qp_fence"]
    cases = [signature(void, int32, CPointer(int32), int32)]

register_global(qp_fence, types.Function(_typing_qp_fence))


@register
class _typing_qp_fence_warp(ConcreteTemplate):
    key = globals()["qp_fence_warp"]
    cases = [signature(void, int32, CPointer(int32), int32)]

register_global(qp_fence_warp, types.Function(_typing_qp_fence_warp))


@register
class _typing_qp_fence_block(ConcreteTemplate):
    key = globals()["qp_fence_block"]
    cases = [signature(void, int32, CPointer(int32), int32)]

register_global(qp_fence_block, types.Function(_typing_qp_fence_block))


@register
class _typing_alltoallmem_warp(ConcreteTemplate):
    key = globals()["alltoallmem_warp"]
    cases = [signature(int32, int32, CPointer(void), CPointer(void), uint64)]

register_global(alltoallmem_warp, types.Function(_typing_alltoallmem_warp))


@register
class _typing_alltoallmem_block(ConcreteTemplate):
    key = globals()["alltoallmem_block"]
    cases = [signature(int32, int32, CPointer(void), CPointer(void), uint64)]

register_global(alltoallmem_block, types.Function(_typing_alltoallmem_block))


@register
class _typing_bfloat16_alltoall_warp(ConcreteTemplate):
    key = globals()["bfloat16_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_alltoall_warp, types.Function(_typing_bfloat16_alltoall_warp))


@register
class _typing_half_alltoall_warp(ConcreteTemplate):
    key = globals()["half_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_alltoall_warp, types.Function(_typing_half_alltoall_warp))


@register
class _typing_float_alltoall_warp(ConcreteTemplate):
    key = globals()["float_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_alltoall_warp, types.Function(_typing_float_alltoall_warp))


@register
class _typing_double_alltoall_warp(ConcreteTemplate):
    key = globals()["double_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_alltoall_warp, types.Function(_typing_double_alltoall_warp))


@register
class _typing_char_alltoall_warp(ConcreteTemplate):
    key = globals()["char_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_alltoall_warp, types.Function(_typing_char_alltoall_warp))


@register
class _typing_short_alltoall_warp(ConcreteTemplate):
    key = globals()["short_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_alltoall_warp, types.Function(_typing_short_alltoall_warp))


@register
class _typing_schar_alltoall_warp(ConcreteTemplate):
    key = globals()["schar_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_alltoall_warp, types.Function(_typing_schar_alltoall_warp))


@register
class _typing_int_alltoall_warp(ConcreteTemplate):
    key = globals()["int_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_alltoall_warp, types.Function(_typing_int_alltoall_warp))


@register
class _typing_long_alltoall_warp(ConcreteTemplate):
    key = globals()["long_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_alltoall_warp, types.Function(_typing_long_alltoall_warp))


@register
class _typing_longlong_alltoall_warp(ConcreteTemplate):
    key = globals()["longlong_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_alltoall_warp, types.Function(_typing_longlong_alltoall_warp))


@register
class _typing_uchar_alltoall_warp(ConcreteTemplate):
    key = globals()["uchar_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_alltoall_warp, types.Function(_typing_uchar_alltoall_warp))


@register
class _typing_ushort_alltoall_warp(ConcreteTemplate):
    key = globals()["ushort_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_alltoall_warp, types.Function(_typing_ushort_alltoall_warp))


@register
class _typing_uint_alltoall_warp(ConcreteTemplate):
    key = globals()["uint_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_alltoall_warp, types.Function(_typing_uint_alltoall_warp))


@register
class _typing_ulong_alltoall_warp(ConcreteTemplate):
    key = globals()["ulong_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_alltoall_warp, types.Function(_typing_ulong_alltoall_warp))


@register
class _typing_ulonglong_alltoall_warp(ConcreteTemplate):
    key = globals()["ulonglong_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_alltoall_warp, types.Function(_typing_ulonglong_alltoall_warp))


@register
class _typing_int8_alltoall_warp(ConcreteTemplate):
    key = globals()["int8_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_alltoall_warp, types.Function(_typing_int8_alltoall_warp))


@register
class _typing_int16_alltoall_warp(ConcreteTemplate):
    key = globals()["int16_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_alltoall_warp, types.Function(_typing_int16_alltoall_warp))


@register
class _typing_int32_alltoall_warp(ConcreteTemplate):
    key = globals()["int32_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_alltoall_warp, types.Function(_typing_int32_alltoall_warp))


@register
class _typing_int64_alltoall_warp(ConcreteTemplate):
    key = globals()["int64_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_alltoall_warp, types.Function(_typing_int64_alltoall_warp))


@register
class _typing_uint8_alltoall_warp(ConcreteTemplate):
    key = globals()["uint8_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_alltoall_warp, types.Function(_typing_uint8_alltoall_warp))


@register
class _typing_uint16_alltoall_warp(ConcreteTemplate):
    key = globals()["uint16_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_alltoall_warp, types.Function(_typing_uint16_alltoall_warp))


@register
class _typing_uint32_alltoall_warp(ConcreteTemplate):
    key = globals()["uint32_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_alltoall_warp, types.Function(_typing_uint32_alltoall_warp))


@register
class _typing_uint64_alltoall_warp(ConcreteTemplate):
    key = globals()["uint64_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_alltoall_warp, types.Function(_typing_uint64_alltoall_warp))


@register
class _typing_size_alltoall_warp(ConcreteTemplate):
    key = globals()["size_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_alltoall_warp, types.Function(_typing_size_alltoall_warp))


@register
class _typing_ptrdiff_alltoall_warp(ConcreteTemplate):
    key = globals()["ptrdiff_alltoall_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(ptrdiff_alltoall_warp, types.Function(_typing_ptrdiff_alltoall_warp))


@register
class _typing_bfloat16_alltoall_block(ConcreteTemplate):
    key = globals()["bfloat16_alltoall_block"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_alltoall_block, types.Function(_typing_bfloat16_alltoall_block))


@register
class _typing_half_alltoall_block(ConcreteTemplate):
    key = globals()["half_alltoall_block"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_alltoall_block, types.Function(_typing_half_alltoall_block))


@register
class _typing_float_alltoall_block(ConcreteTemplate):
    key = globals()["float_alltoall_block"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_alltoall_block, types.Function(_typing_float_alltoall_block))


@register
class _typing_double_alltoall_block(ConcreteTemplate):
    key = globals()["double_alltoall_block"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_alltoall_block, types.Function(_typing_double_alltoall_block))


@register
class _typing_char_alltoall_block(ConcreteTemplate):
    key = globals()["char_alltoall_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_alltoall_block, types.Function(_typing_char_alltoall_block))


@register
class _typing_short_alltoall_block(ConcreteTemplate):
    key = globals()["short_alltoall_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_alltoall_block, types.Function(_typing_short_alltoall_block))


@register
class _typing_schar_alltoall_block(ConcreteTemplate):
    key = globals()["schar_alltoall_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_alltoall_block, types.Function(_typing_schar_alltoall_block))


@register
class _typing_int_alltoall_block(ConcreteTemplate):
    key = globals()["int_alltoall_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_alltoall_block, types.Function(_typing_int_alltoall_block))


@register
class _typing_long_alltoall_block(ConcreteTemplate):
    key = globals()["long_alltoall_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_alltoall_block, types.Function(_typing_long_alltoall_block))


@register
class _typing_longlong_alltoall_block(ConcreteTemplate):
    key = globals()["longlong_alltoall_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_alltoall_block, types.Function(_typing_longlong_alltoall_block))


@register
class _typing_uchar_alltoall_block(ConcreteTemplate):
    key = globals()["uchar_alltoall_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_alltoall_block, types.Function(_typing_uchar_alltoall_block))


@register
class _typing_ushort_alltoall_block(ConcreteTemplate):
    key = globals()["ushort_alltoall_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_alltoall_block, types.Function(_typing_ushort_alltoall_block))


@register
class _typing_uint_alltoall_block(ConcreteTemplate):
    key = globals()["uint_alltoall_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_alltoall_block, types.Function(_typing_uint_alltoall_block))


@register
class _typing_ulong_alltoall_block(ConcreteTemplate):
    key = globals()["ulong_alltoall_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_alltoall_block, types.Function(_typing_ulong_alltoall_block))


@register
class _typing_ulonglong_alltoall_block(ConcreteTemplate):
    key = globals()["ulonglong_alltoall_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_alltoall_block, types.Function(_typing_ulonglong_alltoall_block))


@register
class _typing_int8_alltoall_block(ConcreteTemplate):
    key = globals()["int8_alltoall_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_alltoall_block, types.Function(_typing_int8_alltoall_block))


@register
class _typing_int16_alltoall_block(ConcreteTemplate):
    key = globals()["int16_alltoall_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_alltoall_block, types.Function(_typing_int16_alltoall_block))


@register
class _typing_int32_alltoall_block(ConcreteTemplate):
    key = globals()["int32_alltoall_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_alltoall_block, types.Function(_typing_int32_alltoall_block))


@register
class _typing_int64_alltoall_block(ConcreteTemplate):
    key = globals()["int64_alltoall_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_alltoall_block, types.Function(_typing_int64_alltoall_block))


@register
class _typing_uint8_alltoall_block(ConcreteTemplate):
    key = globals()["uint8_alltoall_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_alltoall_block, types.Function(_typing_uint8_alltoall_block))


@register
class _typing_uint16_alltoall_block(ConcreteTemplate):
    key = globals()["uint16_alltoall_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_alltoall_block, types.Function(_typing_uint16_alltoall_block))


@register
class _typing_uint32_alltoall_block(ConcreteTemplate):
    key = globals()["uint32_alltoall_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_alltoall_block, types.Function(_typing_uint32_alltoall_block))


@register
class _typing_uint64_alltoall_block(ConcreteTemplate):
    key = globals()["uint64_alltoall_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_alltoall_block, types.Function(_typing_uint64_alltoall_block))


@register
class _typing_size_alltoall_block(ConcreteTemplate):
    key = globals()["size_alltoall_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_alltoall_block, types.Function(_typing_size_alltoall_block))


@register
class _typing_ptrdiff_alltoall_block(ConcreteTemplate):
    key = globals()["ptrdiff_alltoall_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(ptrdiff_alltoall_block, types.Function(_typing_ptrdiff_alltoall_block))


@register
class _typing_barrier_warp(ConcreteTemplate):
    key = globals()["barrier_warp"]
    cases = [signature(int32, int32)]

register_global(barrier_warp, types.Function(_typing_barrier_warp))


@register
class _typing_barrier_warpgroup(ConcreteTemplate):
    key = globals()["barrier_warpgroup"]
    cases = [signature(int32, int32)]

register_global(barrier_warpgroup, types.Function(_typing_barrier_warpgroup))


@register
class _typing_barrier_block(ConcreteTemplate):
    key = globals()["barrier_block"]
    cases = [signature(int32, int32)]

register_global(barrier_block, types.Function(_typing_barrier_block))


@register
class _typing_barrier_all_warp(ConcreteTemplate):
    key = globals()["barrier_all_warp"]
    cases = [signature(void, )]

register_global(barrier_all_warp, types.Function(_typing_barrier_all_warp))


@register
class _typing_barrier_all_block(ConcreteTemplate):
    key = globals()["barrier_all_block"]
    cases = [signature(void, )]

register_global(barrier_all_block, types.Function(_typing_barrier_all_block))


@register
class _typing_team_sync_warp(ConcreteTemplate):
    key = globals()["team_sync_warp"]
    cases = [signature(int32, int32)]

register_global(team_sync_warp, types.Function(_typing_team_sync_warp))


@register
class _typing_team_sync_block(ConcreteTemplate):
    key = globals()["team_sync_block"]
    cases = [signature(int32, int32)]

register_global(team_sync_block, types.Function(_typing_team_sync_block))


@register
class _typing_sync_all_warp(ConcreteTemplate):
    key = globals()["sync_all_warp"]
    cases = [signature(void, )]

register_global(sync_all_warp, types.Function(_typing_sync_all_warp))


@register
class _typing_sync_all_block(ConcreteTemplate):
    key = globals()["sync_all_block"]
    cases = [signature(void, )]

register_global(sync_all_block, types.Function(_typing_sync_all_block))


@register
class _typing_broadcastmem_warp(ConcreteTemplate):
    key = globals()["broadcastmem_warp"]
    cases = [signature(int32, int32, CPointer(void), CPointer(void), uint64, int32)]

register_global(broadcastmem_warp, types.Function(_typing_broadcastmem_warp))


@register
class _typing_broadcastmem_block(ConcreteTemplate):
    key = globals()["broadcastmem_block"]
    cases = [signature(int32, int32, CPointer(void), CPointer(void), uint64, int32)]

register_global(broadcastmem_block, types.Function(_typing_broadcastmem_block))


@register
class _typing_bfloat16_broadcast_warp(ConcreteTemplate):
    key = globals()["bfloat16_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)]

register_global(bfloat16_broadcast_warp, types.Function(_typing_bfloat16_broadcast_warp))


@register
class _typing_half_broadcast_warp(ConcreteTemplate):
    key = globals()["half_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64, int32)]

register_global(half_broadcast_warp, types.Function(_typing_half_broadcast_warp))


@register
class _typing_float_broadcast_warp(ConcreteTemplate):
    key = globals()["float_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64, int32)]

register_global(float_broadcast_warp, types.Function(_typing_float_broadcast_warp))


@register
class _typing_double_broadcast_warp(ConcreteTemplate):
    key = globals()["double_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64, int32)]

register_global(double_broadcast_warp, types.Function(_typing_double_broadcast_warp))


@register
class _typing_char_broadcast_warp(ConcreteTemplate):
    key = globals()["char_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(char_broadcast_warp, types.Function(_typing_char_broadcast_warp))


@register
class _typing_short_broadcast_warp(ConcreteTemplate):
    key = globals()["short_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(short_broadcast_warp, types.Function(_typing_short_broadcast_warp))


@register
class _typing_schar_broadcast_warp(ConcreteTemplate):
    key = globals()["schar_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(schar_broadcast_warp, types.Function(_typing_schar_broadcast_warp))


@register
class _typing_int_broadcast_warp(ConcreteTemplate):
    key = globals()["int_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int_broadcast_warp, types.Function(_typing_int_broadcast_warp))


@register
class _typing_long_broadcast_warp(ConcreteTemplate):
    key = globals()["long_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(long_broadcast_warp, types.Function(_typing_long_broadcast_warp))


@register
class _typing_longlong_broadcast_warp(ConcreteTemplate):
    key = globals()["longlong_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(longlong_broadcast_warp, types.Function(_typing_longlong_broadcast_warp))


@register
class _typing_uchar_broadcast_warp(ConcreteTemplate):
    key = globals()["uchar_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uchar_broadcast_warp, types.Function(_typing_uchar_broadcast_warp))


@register
class _typing_ushort_broadcast_warp(ConcreteTemplate):
    key = globals()["ushort_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(ushort_broadcast_warp, types.Function(_typing_ushort_broadcast_warp))


@register
class _typing_uint_broadcast_warp(ConcreteTemplate):
    key = globals()["uint_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint_broadcast_warp, types.Function(_typing_uint_broadcast_warp))


@register
class _typing_ulong_broadcast_warp(ConcreteTemplate):
    key = globals()["ulong_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulong_broadcast_warp, types.Function(_typing_ulong_broadcast_warp))


@register
class _typing_ulonglong_broadcast_warp(ConcreteTemplate):
    key = globals()["ulonglong_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulonglong_broadcast_warp, types.Function(_typing_ulonglong_broadcast_warp))


@register
class _typing_int8_broadcast_warp(ConcreteTemplate):
    key = globals()["int8_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(int8_broadcast_warp, types.Function(_typing_int8_broadcast_warp))


@register
class _typing_int16_broadcast_warp(ConcreteTemplate):
    key = globals()["int16_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(int16_broadcast_warp, types.Function(_typing_int16_broadcast_warp))


@register
class _typing_int32_broadcast_warp(ConcreteTemplate):
    key = globals()["int32_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int32_broadcast_warp, types.Function(_typing_int32_broadcast_warp))


@register
class _typing_int64_broadcast_warp(ConcreteTemplate):
    key = globals()["int64_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(int64_broadcast_warp, types.Function(_typing_int64_broadcast_warp))


@register
class _typing_uint8_broadcast_warp(ConcreteTemplate):
    key = globals()["uint8_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uint8_broadcast_warp, types.Function(_typing_uint8_broadcast_warp))


@register
class _typing_uint16_broadcast_warp(ConcreteTemplate):
    key = globals()["uint16_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(uint16_broadcast_warp, types.Function(_typing_uint16_broadcast_warp))


@register
class _typing_uint32_broadcast_warp(ConcreteTemplate):
    key = globals()["uint32_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint32_broadcast_warp, types.Function(_typing_uint32_broadcast_warp))


@register
class _typing_uint64_broadcast_warp(ConcreteTemplate):
    key = globals()["uint64_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(uint64_broadcast_warp, types.Function(_typing_uint64_broadcast_warp))


@register
class _typing_size_broadcast_warp(ConcreteTemplate):
    key = globals()["size_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(size_broadcast_warp, types.Function(_typing_size_broadcast_warp))


@register
class _typing_ptrdiff_broadcast_warp(ConcreteTemplate):
    key = globals()["ptrdiff_broadcast_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(ptrdiff_broadcast_warp, types.Function(_typing_ptrdiff_broadcast_warp))


@register
class _typing_bfloat16_broadcast_block(ConcreteTemplate):
    key = globals()["bfloat16_broadcast_block"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64, int32)]

register_global(bfloat16_broadcast_block, types.Function(_typing_bfloat16_broadcast_block))


@register
class _typing_half_broadcast_block(ConcreteTemplate):
    key = globals()["half_broadcast_block"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64, int32)]

register_global(half_broadcast_block, types.Function(_typing_half_broadcast_block))


@register
class _typing_float_broadcast_block(ConcreteTemplate):
    key = globals()["float_broadcast_block"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64, int32)]

register_global(float_broadcast_block, types.Function(_typing_float_broadcast_block))


@register
class _typing_double_broadcast_block(ConcreteTemplate):
    key = globals()["double_broadcast_block"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64, int32)]

register_global(double_broadcast_block, types.Function(_typing_double_broadcast_block))


@register
class _typing_char_broadcast_block(ConcreteTemplate):
    key = globals()["char_broadcast_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(char_broadcast_block, types.Function(_typing_char_broadcast_block))


@register
class _typing_short_broadcast_block(ConcreteTemplate):
    key = globals()["short_broadcast_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(short_broadcast_block, types.Function(_typing_short_broadcast_block))


@register
class _typing_schar_broadcast_block(ConcreteTemplate):
    key = globals()["schar_broadcast_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(schar_broadcast_block, types.Function(_typing_schar_broadcast_block))


@register
class _typing_int_broadcast_block(ConcreteTemplate):
    key = globals()["int_broadcast_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int_broadcast_block, types.Function(_typing_int_broadcast_block))


@register
class _typing_long_broadcast_block(ConcreteTemplate):
    key = globals()["long_broadcast_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(long_broadcast_block, types.Function(_typing_long_broadcast_block))


@register
class _typing_longlong_broadcast_block(ConcreteTemplate):
    key = globals()["longlong_broadcast_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(longlong_broadcast_block, types.Function(_typing_longlong_broadcast_block))


@register
class _typing_uchar_broadcast_block(ConcreteTemplate):
    key = globals()["uchar_broadcast_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uchar_broadcast_block, types.Function(_typing_uchar_broadcast_block))


@register
class _typing_ushort_broadcast_block(ConcreteTemplate):
    key = globals()["ushort_broadcast_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(ushort_broadcast_block, types.Function(_typing_ushort_broadcast_block))


@register
class _typing_uint_broadcast_block(ConcreteTemplate):
    key = globals()["uint_broadcast_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint_broadcast_block, types.Function(_typing_uint_broadcast_block))


@register
class _typing_ulong_broadcast_block(ConcreteTemplate):
    key = globals()["ulong_broadcast_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulong_broadcast_block, types.Function(_typing_ulong_broadcast_block))


@register
class _typing_ulonglong_broadcast_block(ConcreteTemplate):
    key = globals()["ulonglong_broadcast_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(ulonglong_broadcast_block, types.Function(_typing_ulonglong_broadcast_block))


@register
class _typing_int8_broadcast_block(ConcreteTemplate):
    key = globals()["int8_broadcast_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64, int32)]

register_global(int8_broadcast_block, types.Function(_typing_int8_broadcast_block))


@register
class _typing_int16_broadcast_block(ConcreteTemplate):
    key = globals()["int16_broadcast_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64, int32)]

register_global(int16_broadcast_block, types.Function(_typing_int16_broadcast_block))


@register
class _typing_int32_broadcast_block(ConcreteTemplate):
    key = globals()["int32_broadcast_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64, int32)]

register_global(int32_broadcast_block, types.Function(_typing_int32_broadcast_block))


@register
class _typing_int64_broadcast_block(ConcreteTemplate):
    key = globals()["int64_broadcast_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(int64_broadcast_block, types.Function(_typing_int64_broadcast_block))


@register
class _typing_uint8_broadcast_block(ConcreteTemplate):
    key = globals()["uint8_broadcast_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64, int32)]

register_global(uint8_broadcast_block, types.Function(_typing_uint8_broadcast_block))


@register
class _typing_uint16_broadcast_block(ConcreteTemplate):
    key = globals()["uint16_broadcast_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64, int32)]

register_global(uint16_broadcast_block, types.Function(_typing_uint16_broadcast_block))


@register
class _typing_uint32_broadcast_block(ConcreteTemplate):
    key = globals()["uint32_broadcast_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64, int32)]

register_global(uint32_broadcast_block, types.Function(_typing_uint32_broadcast_block))


@register
class _typing_uint64_broadcast_block(ConcreteTemplate):
    key = globals()["uint64_broadcast_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(uint64_broadcast_block, types.Function(_typing_uint64_broadcast_block))


@register
class _typing_size_broadcast_block(ConcreteTemplate):
    key = globals()["size_broadcast_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64, int32)]

register_global(size_broadcast_block, types.Function(_typing_size_broadcast_block))


@register
class _typing_ptrdiff_broadcast_block(ConcreteTemplate):
    key = globals()["ptrdiff_broadcast_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64, int32)]

register_global(ptrdiff_broadcast_block, types.Function(_typing_ptrdiff_broadcast_block))


@register
class _typing_fcollectmem_warp(ConcreteTemplate):
    key = globals()["fcollectmem_warp"]
    cases = [signature(int32, int32, CPointer(void), CPointer(void), uint64)]

register_global(fcollectmem_warp, types.Function(_typing_fcollectmem_warp))


@register
class _typing_fcollectmem_block(ConcreteTemplate):
    key = globals()["fcollectmem_block"]
    cases = [signature(int32, int32, CPointer(void), CPointer(void), uint64)]

register_global(fcollectmem_block, types.Function(_typing_fcollectmem_block))


@register
class _typing_bfloat16_fcollect_warp(ConcreteTemplate):
    key = globals()["bfloat16_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_fcollect_warp, types.Function(_typing_bfloat16_fcollect_warp))


@register
class _typing_half_fcollect_warp(ConcreteTemplate):
    key = globals()["half_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_fcollect_warp, types.Function(_typing_half_fcollect_warp))


@register
class _typing_float_fcollect_warp(ConcreteTemplate):
    key = globals()["float_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_fcollect_warp, types.Function(_typing_float_fcollect_warp))


@register
class _typing_double_fcollect_warp(ConcreteTemplate):
    key = globals()["double_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_fcollect_warp, types.Function(_typing_double_fcollect_warp))


@register
class _typing_char_fcollect_warp(ConcreteTemplate):
    key = globals()["char_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_fcollect_warp, types.Function(_typing_char_fcollect_warp))


@register
class _typing_short_fcollect_warp(ConcreteTemplate):
    key = globals()["short_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_fcollect_warp, types.Function(_typing_short_fcollect_warp))


@register
class _typing_schar_fcollect_warp(ConcreteTemplate):
    key = globals()["schar_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_fcollect_warp, types.Function(_typing_schar_fcollect_warp))


@register
class _typing_int_fcollect_warp(ConcreteTemplate):
    key = globals()["int_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_fcollect_warp, types.Function(_typing_int_fcollect_warp))


@register
class _typing_long_fcollect_warp(ConcreteTemplate):
    key = globals()["long_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_fcollect_warp, types.Function(_typing_long_fcollect_warp))


@register
class _typing_longlong_fcollect_warp(ConcreteTemplate):
    key = globals()["longlong_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_fcollect_warp, types.Function(_typing_longlong_fcollect_warp))


@register
class _typing_uchar_fcollect_warp(ConcreteTemplate):
    key = globals()["uchar_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_fcollect_warp, types.Function(_typing_uchar_fcollect_warp))


@register
class _typing_ushort_fcollect_warp(ConcreteTemplate):
    key = globals()["ushort_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_fcollect_warp, types.Function(_typing_ushort_fcollect_warp))


@register
class _typing_uint_fcollect_warp(ConcreteTemplate):
    key = globals()["uint_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_fcollect_warp, types.Function(_typing_uint_fcollect_warp))


@register
class _typing_ulong_fcollect_warp(ConcreteTemplate):
    key = globals()["ulong_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_fcollect_warp, types.Function(_typing_ulong_fcollect_warp))


@register
class _typing_ulonglong_fcollect_warp(ConcreteTemplate):
    key = globals()["ulonglong_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_fcollect_warp, types.Function(_typing_ulonglong_fcollect_warp))


@register
class _typing_int8_fcollect_warp(ConcreteTemplate):
    key = globals()["int8_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_fcollect_warp, types.Function(_typing_int8_fcollect_warp))


@register
class _typing_int16_fcollect_warp(ConcreteTemplate):
    key = globals()["int16_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_fcollect_warp, types.Function(_typing_int16_fcollect_warp))


@register
class _typing_int32_fcollect_warp(ConcreteTemplate):
    key = globals()["int32_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_fcollect_warp, types.Function(_typing_int32_fcollect_warp))


@register
class _typing_int64_fcollect_warp(ConcreteTemplate):
    key = globals()["int64_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_fcollect_warp, types.Function(_typing_int64_fcollect_warp))


@register
class _typing_uint8_fcollect_warp(ConcreteTemplate):
    key = globals()["uint8_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_fcollect_warp, types.Function(_typing_uint8_fcollect_warp))


@register
class _typing_uint16_fcollect_warp(ConcreteTemplate):
    key = globals()["uint16_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_fcollect_warp, types.Function(_typing_uint16_fcollect_warp))


@register
class _typing_uint32_fcollect_warp(ConcreteTemplate):
    key = globals()["uint32_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_fcollect_warp, types.Function(_typing_uint32_fcollect_warp))


@register
class _typing_uint64_fcollect_warp(ConcreteTemplate):
    key = globals()["uint64_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_fcollect_warp, types.Function(_typing_uint64_fcollect_warp))


@register
class _typing_size_fcollect_warp(ConcreteTemplate):
    key = globals()["size_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_fcollect_warp, types.Function(_typing_size_fcollect_warp))


@register
class _typing_ptrdiff_fcollect_warp(ConcreteTemplate):
    key = globals()["ptrdiff_fcollect_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(ptrdiff_fcollect_warp, types.Function(_typing_ptrdiff_fcollect_warp))


@register
class _typing_bfloat16_fcollect_block(ConcreteTemplate):
    key = globals()["bfloat16_fcollect_block"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_fcollect_block, types.Function(_typing_bfloat16_fcollect_block))


@register
class _typing_half_fcollect_block(ConcreteTemplate):
    key = globals()["half_fcollect_block"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_fcollect_block, types.Function(_typing_half_fcollect_block))


@register
class _typing_float_fcollect_block(ConcreteTemplate):
    key = globals()["float_fcollect_block"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_fcollect_block, types.Function(_typing_float_fcollect_block))


@register
class _typing_double_fcollect_block(ConcreteTemplate):
    key = globals()["double_fcollect_block"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_fcollect_block, types.Function(_typing_double_fcollect_block))


@register
class _typing_char_fcollect_block(ConcreteTemplate):
    key = globals()["char_fcollect_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_fcollect_block, types.Function(_typing_char_fcollect_block))


@register
class _typing_short_fcollect_block(ConcreteTemplate):
    key = globals()["short_fcollect_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_fcollect_block, types.Function(_typing_short_fcollect_block))


@register
class _typing_schar_fcollect_block(ConcreteTemplate):
    key = globals()["schar_fcollect_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_fcollect_block, types.Function(_typing_schar_fcollect_block))


@register
class _typing_int_fcollect_block(ConcreteTemplate):
    key = globals()["int_fcollect_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_fcollect_block, types.Function(_typing_int_fcollect_block))


@register
class _typing_long_fcollect_block(ConcreteTemplate):
    key = globals()["long_fcollect_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_fcollect_block, types.Function(_typing_long_fcollect_block))


@register
class _typing_longlong_fcollect_block(ConcreteTemplate):
    key = globals()["longlong_fcollect_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_fcollect_block, types.Function(_typing_longlong_fcollect_block))


@register
class _typing_uchar_fcollect_block(ConcreteTemplate):
    key = globals()["uchar_fcollect_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_fcollect_block, types.Function(_typing_uchar_fcollect_block))


@register
class _typing_ushort_fcollect_block(ConcreteTemplate):
    key = globals()["ushort_fcollect_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_fcollect_block, types.Function(_typing_ushort_fcollect_block))


@register
class _typing_uint_fcollect_block(ConcreteTemplate):
    key = globals()["uint_fcollect_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_fcollect_block, types.Function(_typing_uint_fcollect_block))


@register
class _typing_ulong_fcollect_block(ConcreteTemplate):
    key = globals()["ulong_fcollect_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_fcollect_block, types.Function(_typing_ulong_fcollect_block))


@register
class _typing_ulonglong_fcollect_block(ConcreteTemplate):
    key = globals()["ulonglong_fcollect_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_fcollect_block, types.Function(_typing_ulonglong_fcollect_block))


@register
class _typing_int8_fcollect_block(ConcreteTemplate):
    key = globals()["int8_fcollect_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_fcollect_block, types.Function(_typing_int8_fcollect_block))


@register
class _typing_int16_fcollect_block(ConcreteTemplate):
    key = globals()["int16_fcollect_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_fcollect_block, types.Function(_typing_int16_fcollect_block))


@register
class _typing_int32_fcollect_block(ConcreteTemplate):
    key = globals()["int32_fcollect_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_fcollect_block, types.Function(_typing_int32_fcollect_block))


@register
class _typing_int64_fcollect_block(ConcreteTemplate):
    key = globals()["int64_fcollect_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_fcollect_block, types.Function(_typing_int64_fcollect_block))


@register
class _typing_uint8_fcollect_block(ConcreteTemplate):
    key = globals()["uint8_fcollect_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_fcollect_block, types.Function(_typing_uint8_fcollect_block))


@register
class _typing_uint16_fcollect_block(ConcreteTemplate):
    key = globals()["uint16_fcollect_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_fcollect_block, types.Function(_typing_uint16_fcollect_block))


@register
class _typing_uint32_fcollect_block(ConcreteTemplate):
    key = globals()["uint32_fcollect_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_fcollect_block, types.Function(_typing_uint32_fcollect_block))


@register
class _typing_uint64_fcollect_block(ConcreteTemplate):
    key = globals()["uint64_fcollect_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_fcollect_block, types.Function(_typing_uint64_fcollect_block))


@register
class _typing_size_fcollect_block(ConcreteTemplate):
    key = globals()["size_fcollect_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_fcollect_block, types.Function(_typing_size_fcollect_block))


@register
class _typing_ptrdiff_fcollect_block(ConcreteTemplate):
    key = globals()["ptrdiff_fcollect_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(ptrdiff_fcollect_block, types.Function(_typing_ptrdiff_fcollect_block))


@register
class _typing_uchar_and_reduce_warp(ConcreteTemplate):
    key = globals()["uchar_and_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_and_reduce_warp, types.Function(_typing_uchar_and_reduce_warp))


@register
class _typing_ushort_and_reduce_warp(ConcreteTemplate):
    key = globals()["ushort_and_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_and_reduce_warp, types.Function(_typing_ushort_and_reduce_warp))


@register
class _typing_uint_and_reduce_warp(ConcreteTemplate):
    key = globals()["uint_and_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_and_reduce_warp, types.Function(_typing_uint_and_reduce_warp))


@register
class _typing_ulong_and_reduce_warp(ConcreteTemplate):
    key = globals()["ulong_and_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_and_reduce_warp, types.Function(_typing_ulong_and_reduce_warp))


@register
class _typing_ulonglong_and_reduce_warp(ConcreteTemplate):
    key = globals()["ulonglong_and_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_and_reduce_warp, types.Function(_typing_ulonglong_and_reduce_warp))


@register
class _typing_int8_and_reduce_warp(ConcreteTemplate):
    key = globals()["int8_and_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_and_reduce_warp, types.Function(_typing_int8_and_reduce_warp))


@register
class _typing_int16_and_reduce_warp(ConcreteTemplate):
    key = globals()["int16_and_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_and_reduce_warp, types.Function(_typing_int16_and_reduce_warp))


@register
class _typing_int32_and_reduce_warp(ConcreteTemplate):
    key = globals()["int32_and_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_and_reduce_warp, types.Function(_typing_int32_and_reduce_warp))


@register
class _typing_int64_and_reduce_warp(ConcreteTemplate):
    key = globals()["int64_and_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_and_reduce_warp, types.Function(_typing_int64_and_reduce_warp))


@register
class _typing_uint8_and_reduce_warp(ConcreteTemplate):
    key = globals()["uint8_and_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_and_reduce_warp, types.Function(_typing_uint8_and_reduce_warp))


@register
class _typing_uint16_and_reduce_warp(ConcreteTemplate):
    key = globals()["uint16_and_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_and_reduce_warp, types.Function(_typing_uint16_and_reduce_warp))


@register
class _typing_uint32_and_reduce_warp(ConcreteTemplate):
    key = globals()["uint32_and_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_and_reduce_warp, types.Function(_typing_uint32_and_reduce_warp))


@register
class _typing_uint64_and_reduce_warp(ConcreteTemplate):
    key = globals()["uint64_and_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_and_reduce_warp, types.Function(_typing_uint64_and_reduce_warp))


@register
class _typing_size_and_reduce_warp(ConcreteTemplate):
    key = globals()["size_and_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_and_reduce_warp, types.Function(_typing_size_and_reduce_warp))


@register
class _typing_uchar_or_reduce_warp(ConcreteTemplate):
    key = globals()["uchar_or_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_or_reduce_warp, types.Function(_typing_uchar_or_reduce_warp))


@register
class _typing_ushort_or_reduce_warp(ConcreteTemplate):
    key = globals()["ushort_or_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_or_reduce_warp, types.Function(_typing_ushort_or_reduce_warp))


@register
class _typing_uint_or_reduce_warp(ConcreteTemplate):
    key = globals()["uint_or_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_or_reduce_warp, types.Function(_typing_uint_or_reduce_warp))


@register
class _typing_ulong_or_reduce_warp(ConcreteTemplate):
    key = globals()["ulong_or_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_or_reduce_warp, types.Function(_typing_ulong_or_reduce_warp))


@register
class _typing_ulonglong_or_reduce_warp(ConcreteTemplate):
    key = globals()["ulonglong_or_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_or_reduce_warp, types.Function(_typing_ulonglong_or_reduce_warp))


@register
class _typing_int8_or_reduce_warp(ConcreteTemplate):
    key = globals()["int8_or_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_or_reduce_warp, types.Function(_typing_int8_or_reduce_warp))


@register
class _typing_int16_or_reduce_warp(ConcreteTemplate):
    key = globals()["int16_or_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_or_reduce_warp, types.Function(_typing_int16_or_reduce_warp))


@register
class _typing_int32_or_reduce_warp(ConcreteTemplate):
    key = globals()["int32_or_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_or_reduce_warp, types.Function(_typing_int32_or_reduce_warp))


@register
class _typing_int64_or_reduce_warp(ConcreteTemplate):
    key = globals()["int64_or_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_or_reduce_warp, types.Function(_typing_int64_or_reduce_warp))


@register
class _typing_uint8_or_reduce_warp(ConcreteTemplate):
    key = globals()["uint8_or_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_or_reduce_warp, types.Function(_typing_uint8_or_reduce_warp))


@register
class _typing_uint16_or_reduce_warp(ConcreteTemplate):
    key = globals()["uint16_or_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_or_reduce_warp, types.Function(_typing_uint16_or_reduce_warp))


@register
class _typing_uint32_or_reduce_warp(ConcreteTemplate):
    key = globals()["uint32_or_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_or_reduce_warp, types.Function(_typing_uint32_or_reduce_warp))


@register
class _typing_uint64_or_reduce_warp(ConcreteTemplate):
    key = globals()["uint64_or_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_or_reduce_warp, types.Function(_typing_uint64_or_reduce_warp))


@register
class _typing_size_or_reduce_warp(ConcreteTemplate):
    key = globals()["size_or_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_or_reduce_warp, types.Function(_typing_size_or_reduce_warp))


@register
class _typing_uchar_xor_reduce_warp(ConcreteTemplate):
    key = globals()["uchar_xor_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_xor_reduce_warp, types.Function(_typing_uchar_xor_reduce_warp))


@register
class _typing_ushort_xor_reduce_warp(ConcreteTemplate):
    key = globals()["ushort_xor_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_xor_reduce_warp, types.Function(_typing_ushort_xor_reduce_warp))


@register
class _typing_uint_xor_reduce_warp(ConcreteTemplate):
    key = globals()["uint_xor_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_xor_reduce_warp, types.Function(_typing_uint_xor_reduce_warp))


@register
class _typing_ulong_xor_reduce_warp(ConcreteTemplate):
    key = globals()["ulong_xor_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_xor_reduce_warp, types.Function(_typing_ulong_xor_reduce_warp))


@register
class _typing_ulonglong_xor_reduce_warp(ConcreteTemplate):
    key = globals()["ulonglong_xor_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_xor_reduce_warp, types.Function(_typing_ulonglong_xor_reduce_warp))


@register
class _typing_int8_xor_reduce_warp(ConcreteTemplate):
    key = globals()["int8_xor_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_xor_reduce_warp, types.Function(_typing_int8_xor_reduce_warp))


@register
class _typing_int16_xor_reduce_warp(ConcreteTemplate):
    key = globals()["int16_xor_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_xor_reduce_warp, types.Function(_typing_int16_xor_reduce_warp))


@register
class _typing_int32_xor_reduce_warp(ConcreteTemplate):
    key = globals()["int32_xor_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_xor_reduce_warp, types.Function(_typing_int32_xor_reduce_warp))


@register
class _typing_int64_xor_reduce_warp(ConcreteTemplate):
    key = globals()["int64_xor_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_xor_reduce_warp, types.Function(_typing_int64_xor_reduce_warp))


@register
class _typing_uint8_xor_reduce_warp(ConcreteTemplate):
    key = globals()["uint8_xor_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_xor_reduce_warp, types.Function(_typing_uint8_xor_reduce_warp))


@register
class _typing_uint16_xor_reduce_warp(ConcreteTemplate):
    key = globals()["uint16_xor_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_xor_reduce_warp, types.Function(_typing_uint16_xor_reduce_warp))


@register
class _typing_uint32_xor_reduce_warp(ConcreteTemplate):
    key = globals()["uint32_xor_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_xor_reduce_warp, types.Function(_typing_uint32_xor_reduce_warp))


@register
class _typing_uint64_xor_reduce_warp(ConcreteTemplate):
    key = globals()["uint64_xor_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_xor_reduce_warp, types.Function(_typing_uint64_xor_reduce_warp))


@register
class _typing_size_xor_reduce_warp(ConcreteTemplate):
    key = globals()["size_xor_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_xor_reduce_warp, types.Function(_typing_size_xor_reduce_warp))


@register
class _typing_uchar_max_reduce_warp(ConcreteTemplate):
    key = globals()["uchar_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_max_reduce_warp, types.Function(_typing_uchar_max_reduce_warp))


@register
class _typing_ushort_max_reduce_warp(ConcreteTemplate):
    key = globals()["ushort_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_max_reduce_warp, types.Function(_typing_ushort_max_reduce_warp))


@register
class _typing_uint_max_reduce_warp(ConcreteTemplate):
    key = globals()["uint_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_max_reduce_warp, types.Function(_typing_uint_max_reduce_warp))


@register
class _typing_ulong_max_reduce_warp(ConcreteTemplate):
    key = globals()["ulong_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_max_reduce_warp, types.Function(_typing_ulong_max_reduce_warp))


@register
class _typing_ulonglong_max_reduce_warp(ConcreteTemplate):
    key = globals()["ulonglong_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_max_reduce_warp, types.Function(_typing_ulonglong_max_reduce_warp))


@register
class _typing_int8_max_reduce_warp(ConcreteTemplate):
    key = globals()["int8_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_max_reduce_warp, types.Function(_typing_int8_max_reduce_warp))


@register
class _typing_int16_max_reduce_warp(ConcreteTemplate):
    key = globals()["int16_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_max_reduce_warp, types.Function(_typing_int16_max_reduce_warp))


@register
class _typing_int32_max_reduce_warp(ConcreteTemplate):
    key = globals()["int32_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_max_reduce_warp, types.Function(_typing_int32_max_reduce_warp))


@register
class _typing_int64_max_reduce_warp(ConcreteTemplate):
    key = globals()["int64_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_max_reduce_warp, types.Function(_typing_int64_max_reduce_warp))


@register
class _typing_uint8_max_reduce_warp(ConcreteTemplate):
    key = globals()["uint8_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_max_reduce_warp, types.Function(_typing_uint8_max_reduce_warp))


@register
class _typing_uint16_max_reduce_warp(ConcreteTemplate):
    key = globals()["uint16_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_max_reduce_warp, types.Function(_typing_uint16_max_reduce_warp))


@register
class _typing_uint32_max_reduce_warp(ConcreteTemplate):
    key = globals()["uint32_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_max_reduce_warp, types.Function(_typing_uint32_max_reduce_warp))


@register
class _typing_uint64_max_reduce_warp(ConcreteTemplate):
    key = globals()["uint64_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_max_reduce_warp, types.Function(_typing_uint64_max_reduce_warp))


@register
class _typing_size_max_reduce_warp(ConcreteTemplate):
    key = globals()["size_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_max_reduce_warp, types.Function(_typing_size_max_reduce_warp))


@register
class _typing_char_max_reduce_warp(ConcreteTemplate):
    key = globals()["char_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_max_reduce_warp, types.Function(_typing_char_max_reduce_warp))


@register
class _typing_schar_max_reduce_warp(ConcreteTemplate):
    key = globals()["schar_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_max_reduce_warp, types.Function(_typing_schar_max_reduce_warp))


@register
class _typing_short_max_reduce_warp(ConcreteTemplate):
    key = globals()["short_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_max_reduce_warp, types.Function(_typing_short_max_reduce_warp))


@register
class _typing_int_max_reduce_warp(ConcreteTemplate):
    key = globals()["int_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_max_reduce_warp, types.Function(_typing_int_max_reduce_warp))


@register
class _typing_long_max_reduce_warp(ConcreteTemplate):
    key = globals()["long_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_max_reduce_warp, types.Function(_typing_long_max_reduce_warp))


@register
class _typing_longlong_max_reduce_warp(ConcreteTemplate):
    key = globals()["longlong_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_max_reduce_warp, types.Function(_typing_longlong_max_reduce_warp))


@register
class _typing_bfloat16_max_reduce_warp(ConcreteTemplate):
    key = globals()["bfloat16_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_max_reduce_warp, types.Function(_typing_bfloat16_max_reduce_warp))


@register
class _typing_half_max_reduce_warp(ConcreteTemplate):
    key = globals()["half_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_max_reduce_warp, types.Function(_typing_half_max_reduce_warp))


@register
class _typing_float_max_reduce_warp(ConcreteTemplate):
    key = globals()["float_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_max_reduce_warp, types.Function(_typing_float_max_reduce_warp))


@register
class _typing_double_max_reduce_warp(ConcreteTemplate):
    key = globals()["double_max_reduce_warp"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_max_reduce_warp, types.Function(_typing_double_max_reduce_warp))


@register
class _typing_uchar_min_reduce_warp(ConcreteTemplate):
    key = globals()["uchar_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_min_reduce_warp, types.Function(_typing_uchar_min_reduce_warp))


@register
class _typing_ushort_min_reduce_warp(ConcreteTemplate):
    key = globals()["ushort_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_min_reduce_warp, types.Function(_typing_ushort_min_reduce_warp))


@register
class _typing_uint_min_reduce_warp(ConcreteTemplate):
    key = globals()["uint_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_min_reduce_warp, types.Function(_typing_uint_min_reduce_warp))


@register
class _typing_ulong_min_reduce_warp(ConcreteTemplate):
    key = globals()["ulong_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_min_reduce_warp, types.Function(_typing_ulong_min_reduce_warp))


@register
class _typing_ulonglong_min_reduce_warp(ConcreteTemplate):
    key = globals()["ulonglong_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_min_reduce_warp, types.Function(_typing_ulonglong_min_reduce_warp))


@register
class _typing_int8_min_reduce_warp(ConcreteTemplate):
    key = globals()["int8_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_min_reduce_warp, types.Function(_typing_int8_min_reduce_warp))


@register
class _typing_int16_min_reduce_warp(ConcreteTemplate):
    key = globals()["int16_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_min_reduce_warp, types.Function(_typing_int16_min_reduce_warp))


@register
class _typing_int32_min_reduce_warp(ConcreteTemplate):
    key = globals()["int32_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_min_reduce_warp, types.Function(_typing_int32_min_reduce_warp))


@register
class _typing_int64_min_reduce_warp(ConcreteTemplate):
    key = globals()["int64_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_min_reduce_warp, types.Function(_typing_int64_min_reduce_warp))


@register
class _typing_uint8_min_reduce_warp(ConcreteTemplate):
    key = globals()["uint8_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_min_reduce_warp, types.Function(_typing_uint8_min_reduce_warp))


@register
class _typing_uint16_min_reduce_warp(ConcreteTemplate):
    key = globals()["uint16_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_min_reduce_warp, types.Function(_typing_uint16_min_reduce_warp))


@register
class _typing_uint32_min_reduce_warp(ConcreteTemplate):
    key = globals()["uint32_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_min_reduce_warp, types.Function(_typing_uint32_min_reduce_warp))


@register
class _typing_uint64_min_reduce_warp(ConcreteTemplate):
    key = globals()["uint64_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_min_reduce_warp, types.Function(_typing_uint64_min_reduce_warp))


@register
class _typing_size_min_reduce_warp(ConcreteTemplate):
    key = globals()["size_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_min_reduce_warp, types.Function(_typing_size_min_reduce_warp))


@register
class _typing_char_min_reduce_warp(ConcreteTemplate):
    key = globals()["char_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_min_reduce_warp, types.Function(_typing_char_min_reduce_warp))


@register
class _typing_schar_min_reduce_warp(ConcreteTemplate):
    key = globals()["schar_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_min_reduce_warp, types.Function(_typing_schar_min_reduce_warp))


@register
class _typing_short_min_reduce_warp(ConcreteTemplate):
    key = globals()["short_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_min_reduce_warp, types.Function(_typing_short_min_reduce_warp))


@register
class _typing_int_min_reduce_warp(ConcreteTemplate):
    key = globals()["int_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_min_reduce_warp, types.Function(_typing_int_min_reduce_warp))


@register
class _typing_long_min_reduce_warp(ConcreteTemplate):
    key = globals()["long_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_min_reduce_warp, types.Function(_typing_long_min_reduce_warp))


@register
class _typing_longlong_min_reduce_warp(ConcreteTemplate):
    key = globals()["longlong_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_min_reduce_warp, types.Function(_typing_longlong_min_reduce_warp))


@register
class _typing_bfloat16_min_reduce_warp(ConcreteTemplate):
    key = globals()["bfloat16_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_min_reduce_warp, types.Function(_typing_bfloat16_min_reduce_warp))


@register
class _typing_half_min_reduce_warp(ConcreteTemplate):
    key = globals()["half_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_min_reduce_warp, types.Function(_typing_half_min_reduce_warp))


@register
class _typing_float_min_reduce_warp(ConcreteTemplate):
    key = globals()["float_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_min_reduce_warp, types.Function(_typing_float_min_reduce_warp))


@register
class _typing_double_min_reduce_warp(ConcreteTemplate):
    key = globals()["double_min_reduce_warp"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_min_reduce_warp, types.Function(_typing_double_min_reduce_warp))


@register
class _typing_uchar_sum_reduce_warp(ConcreteTemplate):
    key = globals()["uchar_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_sum_reduce_warp, types.Function(_typing_uchar_sum_reduce_warp))


@register
class _typing_ushort_sum_reduce_warp(ConcreteTemplate):
    key = globals()["ushort_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_sum_reduce_warp, types.Function(_typing_ushort_sum_reduce_warp))


@register
class _typing_uint_sum_reduce_warp(ConcreteTemplate):
    key = globals()["uint_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_sum_reduce_warp, types.Function(_typing_uint_sum_reduce_warp))


@register
class _typing_ulong_sum_reduce_warp(ConcreteTemplate):
    key = globals()["ulong_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_sum_reduce_warp, types.Function(_typing_ulong_sum_reduce_warp))


@register
class _typing_ulonglong_sum_reduce_warp(ConcreteTemplate):
    key = globals()["ulonglong_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_sum_reduce_warp, types.Function(_typing_ulonglong_sum_reduce_warp))


@register
class _typing_int8_sum_reduce_warp(ConcreteTemplate):
    key = globals()["int8_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_sum_reduce_warp, types.Function(_typing_int8_sum_reduce_warp))


@register
class _typing_int16_sum_reduce_warp(ConcreteTemplate):
    key = globals()["int16_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_sum_reduce_warp, types.Function(_typing_int16_sum_reduce_warp))


@register
class _typing_int32_sum_reduce_warp(ConcreteTemplate):
    key = globals()["int32_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_sum_reduce_warp, types.Function(_typing_int32_sum_reduce_warp))


@register
class _typing_int64_sum_reduce_warp(ConcreteTemplate):
    key = globals()["int64_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_sum_reduce_warp, types.Function(_typing_int64_sum_reduce_warp))


@register
class _typing_uint8_sum_reduce_warp(ConcreteTemplate):
    key = globals()["uint8_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_sum_reduce_warp, types.Function(_typing_uint8_sum_reduce_warp))


@register
class _typing_uint16_sum_reduce_warp(ConcreteTemplate):
    key = globals()["uint16_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_sum_reduce_warp, types.Function(_typing_uint16_sum_reduce_warp))


@register
class _typing_uint32_sum_reduce_warp(ConcreteTemplate):
    key = globals()["uint32_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_sum_reduce_warp, types.Function(_typing_uint32_sum_reduce_warp))


@register
class _typing_uint64_sum_reduce_warp(ConcreteTemplate):
    key = globals()["uint64_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_sum_reduce_warp, types.Function(_typing_uint64_sum_reduce_warp))


@register
class _typing_size_sum_reduce_warp(ConcreteTemplate):
    key = globals()["size_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_sum_reduce_warp, types.Function(_typing_size_sum_reduce_warp))


@register
class _typing_char_sum_reduce_warp(ConcreteTemplate):
    key = globals()["char_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_sum_reduce_warp, types.Function(_typing_char_sum_reduce_warp))


@register
class _typing_schar_sum_reduce_warp(ConcreteTemplate):
    key = globals()["schar_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_sum_reduce_warp, types.Function(_typing_schar_sum_reduce_warp))


@register
class _typing_short_sum_reduce_warp(ConcreteTemplate):
    key = globals()["short_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_sum_reduce_warp, types.Function(_typing_short_sum_reduce_warp))


@register
class _typing_int_sum_reduce_warp(ConcreteTemplate):
    key = globals()["int_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_sum_reduce_warp, types.Function(_typing_int_sum_reduce_warp))


@register
class _typing_long_sum_reduce_warp(ConcreteTemplate):
    key = globals()["long_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_sum_reduce_warp, types.Function(_typing_long_sum_reduce_warp))


@register
class _typing_longlong_sum_reduce_warp(ConcreteTemplate):
    key = globals()["longlong_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_sum_reduce_warp, types.Function(_typing_longlong_sum_reduce_warp))


@register
class _typing_bfloat16_sum_reduce_warp(ConcreteTemplate):
    key = globals()["bfloat16_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_sum_reduce_warp, types.Function(_typing_bfloat16_sum_reduce_warp))


@register
class _typing_half_sum_reduce_warp(ConcreteTemplate):
    key = globals()["half_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_sum_reduce_warp, types.Function(_typing_half_sum_reduce_warp))


@register
class _typing_float_sum_reduce_warp(ConcreteTemplate):
    key = globals()["float_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_sum_reduce_warp, types.Function(_typing_float_sum_reduce_warp))


@register
class _typing_double_sum_reduce_warp(ConcreteTemplate):
    key = globals()["double_sum_reduce_warp"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_sum_reduce_warp, types.Function(_typing_double_sum_reduce_warp))


@register
class _typing_uchar_prod_reduce_warp(ConcreteTemplate):
    key = globals()["uchar_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_prod_reduce_warp, types.Function(_typing_uchar_prod_reduce_warp))


@register
class _typing_ushort_prod_reduce_warp(ConcreteTemplate):
    key = globals()["ushort_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_prod_reduce_warp, types.Function(_typing_ushort_prod_reduce_warp))


@register
class _typing_uint_prod_reduce_warp(ConcreteTemplate):
    key = globals()["uint_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_prod_reduce_warp, types.Function(_typing_uint_prod_reduce_warp))


@register
class _typing_ulong_prod_reduce_warp(ConcreteTemplate):
    key = globals()["ulong_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_prod_reduce_warp, types.Function(_typing_ulong_prod_reduce_warp))


@register
class _typing_ulonglong_prod_reduce_warp(ConcreteTemplate):
    key = globals()["ulonglong_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_prod_reduce_warp, types.Function(_typing_ulonglong_prod_reduce_warp))


@register
class _typing_int8_prod_reduce_warp(ConcreteTemplate):
    key = globals()["int8_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_prod_reduce_warp, types.Function(_typing_int8_prod_reduce_warp))


@register
class _typing_int16_prod_reduce_warp(ConcreteTemplate):
    key = globals()["int16_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_prod_reduce_warp, types.Function(_typing_int16_prod_reduce_warp))


@register
class _typing_int32_prod_reduce_warp(ConcreteTemplate):
    key = globals()["int32_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_prod_reduce_warp, types.Function(_typing_int32_prod_reduce_warp))


@register
class _typing_int64_prod_reduce_warp(ConcreteTemplate):
    key = globals()["int64_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_prod_reduce_warp, types.Function(_typing_int64_prod_reduce_warp))


@register
class _typing_uint8_prod_reduce_warp(ConcreteTemplate):
    key = globals()["uint8_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_prod_reduce_warp, types.Function(_typing_uint8_prod_reduce_warp))


@register
class _typing_uint16_prod_reduce_warp(ConcreteTemplate):
    key = globals()["uint16_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_prod_reduce_warp, types.Function(_typing_uint16_prod_reduce_warp))


@register
class _typing_uint32_prod_reduce_warp(ConcreteTemplate):
    key = globals()["uint32_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_prod_reduce_warp, types.Function(_typing_uint32_prod_reduce_warp))


@register
class _typing_uint64_prod_reduce_warp(ConcreteTemplate):
    key = globals()["uint64_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_prod_reduce_warp, types.Function(_typing_uint64_prod_reduce_warp))


@register
class _typing_size_prod_reduce_warp(ConcreteTemplate):
    key = globals()["size_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_prod_reduce_warp, types.Function(_typing_size_prod_reduce_warp))


@register
class _typing_char_prod_reduce_warp(ConcreteTemplate):
    key = globals()["char_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_prod_reduce_warp, types.Function(_typing_char_prod_reduce_warp))


@register
class _typing_schar_prod_reduce_warp(ConcreteTemplate):
    key = globals()["schar_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_prod_reduce_warp, types.Function(_typing_schar_prod_reduce_warp))


@register
class _typing_short_prod_reduce_warp(ConcreteTemplate):
    key = globals()["short_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_prod_reduce_warp, types.Function(_typing_short_prod_reduce_warp))


@register
class _typing_int_prod_reduce_warp(ConcreteTemplate):
    key = globals()["int_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_prod_reduce_warp, types.Function(_typing_int_prod_reduce_warp))


@register
class _typing_long_prod_reduce_warp(ConcreteTemplate):
    key = globals()["long_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_prod_reduce_warp, types.Function(_typing_long_prod_reduce_warp))


@register
class _typing_longlong_prod_reduce_warp(ConcreteTemplate):
    key = globals()["longlong_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_prod_reduce_warp, types.Function(_typing_longlong_prod_reduce_warp))


@register
class _typing_bfloat16_prod_reduce_warp(ConcreteTemplate):
    key = globals()["bfloat16_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_prod_reduce_warp, types.Function(_typing_bfloat16_prod_reduce_warp))


@register
class _typing_half_prod_reduce_warp(ConcreteTemplate):
    key = globals()["half_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_prod_reduce_warp, types.Function(_typing_half_prod_reduce_warp))


@register
class _typing_float_prod_reduce_warp(ConcreteTemplate):
    key = globals()["float_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_prod_reduce_warp, types.Function(_typing_float_prod_reduce_warp))


@register
class _typing_double_prod_reduce_warp(ConcreteTemplate):
    key = globals()["double_prod_reduce_warp"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_prod_reduce_warp, types.Function(_typing_double_prod_reduce_warp))


@register
class _typing_uchar_and_reduce_block(ConcreteTemplate):
    key = globals()["uchar_and_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_and_reduce_block, types.Function(_typing_uchar_and_reduce_block))


@register
class _typing_ushort_and_reduce_block(ConcreteTemplate):
    key = globals()["ushort_and_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_and_reduce_block, types.Function(_typing_ushort_and_reduce_block))


@register
class _typing_uint_and_reduce_block(ConcreteTemplate):
    key = globals()["uint_and_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_and_reduce_block, types.Function(_typing_uint_and_reduce_block))


@register
class _typing_ulong_and_reduce_block(ConcreteTemplate):
    key = globals()["ulong_and_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_and_reduce_block, types.Function(_typing_ulong_and_reduce_block))


@register
class _typing_ulonglong_and_reduce_block(ConcreteTemplate):
    key = globals()["ulonglong_and_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_and_reduce_block, types.Function(_typing_ulonglong_and_reduce_block))


@register
class _typing_int8_and_reduce_block(ConcreteTemplate):
    key = globals()["int8_and_reduce_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_and_reduce_block, types.Function(_typing_int8_and_reduce_block))


@register
class _typing_int16_and_reduce_block(ConcreteTemplate):
    key = globals()["int16_and_reduce_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_and_reduce_block, types.Function(_typing_int16_and_reduce_block))


@register
class _typing_int32_and_reduce_block(ConcreteTemplate):
    key = globals()["int32_and_reduce_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_and_reduce_block, types.Function(_typing_int32_and_reduce_block))


@register
class _typing_int64_and_reduce_block(ConcreteTemplate):
    key = globals()["int64_and_reduce_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_and_reduce_block, types.Function(_typing_int64_and_reduce_block))


@register
class _typing_uint8_and_reduce_block(ConcreteTemplate):
    key = globals()["uint8_and_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_and_reduce_block, types.Function(_typing_uint8_and_reduce_block))


@register
class _typing_uint16_and_reduce_block(ConcreteTemplate):
    key = globals()["uint16_and_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_and_reduce_block, types.Function(_typing_uint16_and_reduce_block))


@register
class _typing_uint32_and_reduce_block(ConcreteTemplate):
    key = globals()["uint32_and_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_and_reduce_block, types.Function(_typing_uint32_and_reduce_block))


@register
class _typing_uint64_and_reduce_block(ConcreteTemplate):
    key = globals()["uint64_and_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_and_reduce_block, types.Function(_typing_uint64_and_reduce_block))


@register
class _typing_size_and_reduce_block(ConcreteTemplate):
    key = globals()["size_and_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_and_reduce_block, types.Function(_typing_size_and_reduce_block))


@register
class _typing_uchar_or_reduce_block(ConcreteTemplate):
    key = globals()["uchar_or_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_or_reduce_block, types.Function(_typing_uchar_or_reduce_block))


@register
class _typing_ushort_or_reduce_block(ConcreteTemplate):
    key = globals()["ushort_or_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_or_reduce_block, types.Function(_typing_ushort_or_reduce_block))


@register
class _typing_uint_or_reduce_block(ConcreteTemplate):
    key = globals()["uint_or_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_or_reduce_block, types.Function(_typing_uint_or_reduce_block))


@register
class _typing_ulong_or_reduce_block(ConcreteTemplate):
    key = globals()["ulong_or_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_or_reduce_block, types.Function(_typing_ulong_or_reduce_block))


@register
class _typing_ulonglong_or_reduce_block(ConcreteTemplate):
    key = globals()["ulonglong_or_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_or_reduce_block, types.Function(_typing_ulonglong_or_reduce_block))


@register
class _typing_int8_or_reduce_block(ConcreteTemplate):
    key = globals()["int8_or_reduce_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_or_reduce_block, types.Function(_typing_int8_or_reduce_block))


@register
class _typing_int16_or_reduce_block(ConcreteTemplate):
    key = globals()["int16_or_reduce_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_or_reduce_block, types.Function(_typing_int16_or_reduce_block))


@register
class _typing_int32_or_reduce_block(ConcreteTemplate):
    key = globals()["int32_or_reduce_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_or_reduce_block, types.Function(_typing_int32_or_reduce_block))


@register
class _typing_int64_or_reduce_block(ConcreteTemplate):
    key = globals()["int64_or_reduce_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_or_reduce_block, types.Function(_typing_int64_or_reduce_block))


@register
class _typing_uint8_or_reduce_block(ConcreteTemplate):
    key = globals()["uint8_or_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_or_reduce_block, types.Function(_typing_uint8_or_reduce_block))


@register
class _typing_uint16_or_reduce_block(ConcreteTemplate):
    key = globals()["uint16_or_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_or_reduce_block, types.Function(_typing_uint16_or_reduce_block))


@register
class _typing_uint32_or_reduce_block(ConcreteTemplate):
    key = globals()["uint32_or_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_or_reduce_block, types.Function(_typing_uint32_or_reduce_block))


@register
class _typing_uint64_or_reduce_block(ConcreteTemplate):
    key = globals()["uint64_or_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_or_reduce_block, types.Function(_typing_uint64_or_reduce_block))


@register
class _typing_size_or_reduce_block(ConcreteTemplate):
    key = globals()["size_or_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_or_reduce_block, types.Function(_typing_size_or_reduce_block))


@register
class _typing_uchar_xor_reduce_block(ConcreteTemplate):
    key = globals()["uchar_xor_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_xor_reduce_block, types.Function(_typing_uchar_xor_reduce_block))


@register
class _typing_ushort_xor_reduce_block(ConcreteTemplate):
    key = globals()["ushort_xor_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_xor_reduce_block, types.Function(_typing_ushort_xor_reduce_block))


@register
class _typing_uint_xor_reduce_block(ConcreteTemplate):
    key = globals()["uint_xor_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_xor_reduce_block, types.Function(_typing_uint_xor_reduce_block))


@register
class _typing_ulong_xor_reduce_block(ConcreteTemplate):
    key = globals()["ulong_xor_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_xor_reduce_block, types.Function(_typing_ulong_xor_reduce_block))


@register
class _typing_ulonglong_xor_reduce_block(ConcreteTemplate):
    key = globals()["ulonglong_xor_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_xor_reduce_block, types.Function(_typing_ulonglong_xor_reduce_block))


@register
class _typing_int8_xor_reduce_block(ConcreteTemplate):
    key = globals()["int8_xor_reduce_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_xor_reduce_block, types.Function(_typing_int8_xor_reduce_block))


@register
class _typing_int16_xor_reduce_block(ConcreteTemplate):
    key = globals()["int16_xor_reduce_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_xor_reduce_block, types.Function(_typing_int16_xor_reduce_block))


@register
class _typing_int32_xor_reduce_block(ConcreteTemplate):
    key = globals()["int32_xor_reduce_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_xor_reduce_block, types.Function(_typing_int32_xor_reduce_block))


@register
class _typing_int64_xor_reduce_block(ConcreteTemplate):
    key = globals()["int64_xor_reduce_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_xor_reduce_block, types.Function(_typing_int64_xor_reduce_block))


@register
class _typing_uint8_xor_reduce_block(ConcreteTemplate):
    key = globals()["uint8_xor_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_xor_reduce_block, types.Function(_typing_uint8_xor_reduce_block))


@register
class _typing_uint16_xor_reduce_block(ConcreteTemplate):
    key = globals()["uint16_xor_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_xor_reduce_block, types.Function(_typing_uint16_xor_reduce_block))


@register
class _typing_uint32_xor_reduce_block(ConcreteTemplate):
    key = globals()["uint32_xor_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_xor_reduce_block, types.Function(_typing_uint32_xor_reduce_block))


@register
class _typing_uint64_xor_reduce_block(ConcreteTemplate):
    key = globals()["uint64_xor_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_xor_reduce_block, types.Function(_typing_uint64_xor_reduce_block))


@register
class _typing_size_xor_reduce_block(ConcreteTemplate):
    key = globals()["size_xor_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_xor_reduce_block, types.Function(_typing_size_xor_reduce_block))


@register
class _typing_uchar_max_reduce_block(ConcreteTemplate):
    key = globals()["uchar_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_max_reduce_block, types.Function(_typing_uchar_max_reduce_block))


@register
class _typing_ushort_max_reduce_block(ConcreteTemplate):
    key = globals()["ushort_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_max_reduce_block, types.Function(_typing_ushort_max_reduce_block))


@register
class _typing_uint_max_reduce_block(ConcreteTemplate):
    key = globals()["uint_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_max_reduce_block, types.Function(_typing_uint_max_reduce_block))


@register
class _typing_ulong_max_reduce_block(ConcreteTemplate):
    key = globals()["ulong_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_max_reduce_block, types.Function(_typing_ulong_max_reduce_block))


@register
class _typing_ulonglong_max_reduce_block(ConcreteTemplate):
    key = globals()["ulonglong_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_max_reduce_block, types.Function(_typing_ulonglong_max_reduce_block))


@register
class _typing_int8_max_reduce_block(ConcreteTemplate):
    key = globals()["int8_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_max_reduce_block, types.Function(_typing_int8_max_reduce_block))


@register
class _typing_int16_max_reduce_block(ConcreteTemplate):
    key = globals()["int16_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_max_reduce_block, types.Function(_typing_int16_max_reduce_block))


@register
class _typing_int32_max_reduce_block(ConcreteTemplate):
    key = globals()["int32_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_max_reduce_block, types.Function(_typing_int32_max_reduce_block))


@register
class _typing_int64_max_reduce_block(ConcreteTemplate):
    key = globals()["int64_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_max_reduce_block, types.Function(_typing_int64_max_reduce_block))


@register
class _typing_uint8_max_reduce_block(ConcreteTemplate):
    key = globals()["uint8_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_max_reduce_block, types.Function(_typing_uint8_max_reduce_block))


@register
class _typing_uint16_max_reduce_block(ConcreteTemplate):
    key = globals()["uint16_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_max_reduce_block, types.Function(_typing_uint16_max_reduce_block))


@register
class _typing_uint32_max_reduce_block(ConcreteTemplate):
    key = globals()["uint32_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_max_reduce_block, types.Function(_typing_uint32_max_reduce_block))


@register
class _typing_uint64_max_reduce_block(ConcreteTemplate):
    key = globals()["uint64_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_max_reduce_block, types.Function(_typing_uint64_max_reduce_block))


@register
class _typing_size_max_reduce_block(ConcreteTemplate):
    key = globals()["size_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_max_reduce_block, types.Function(_typing_size_max_reduce_block))


@register
class _typing_char_max_reduce_block(ConcreteTemplate):
    key = globals()["char_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_max_reduce_block, types.Function(_typing_char_max_reduce_block))


@register
class _typing_schar_max_reduce_block(ConcreteTemplate):
    key = globals()["schar_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_max_reduce_block, types.Function(_typing_schar_max_reduce_block))


@register
class _typing_short_max_reduce_block(ConcreteTemplate):
    key = globals()["short_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_max_reduce_block, types.Function(_typing_short_max_reduce_block))


@register
class _typing_int_max_reduce_block(ConcreteTemplate):
    key = globals()["int_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_max_reduce_block, types.Function(_typing_int_max_reduce_block))


@register
class _typing_long_max_reduce_block(ConcreteTemplate):
    key = globals()["long_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_max_reduce_block, types.Function(_typing_long_max_reduce_block))


@register
class _typing_longlong_max_reduce_block(ConcreteTemplate):
    key = globals()["longlong_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_max_reduce_block, types.Function(_typing_longlong_max_reduce_block))


@register
class _typing_bfloat16_max_reduce_block(ConcreteTemplate):
    key = globals()["bfloat16_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_max_reduce_block, types.Function(_typing_bfloat16_max_reduce_block))


@register
class _typing_half_max_reduce_block(ConcreteTemplate):
    key = globals()["half_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_max_reduce_block, types.Function(_typing_half_max_reduce_block))


@register
class _typing_float_max_reduce_block(ConcreteTemplate):
    key = globals()["float_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_max_reduce_block, types.Function(_typing_float_max_reduce_block))


@register
class _typing_double_max_reduce_block(ConcreteTemplate):
    key = globals()["double_max_reduce_block"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_max_reduce_block, types.Function(_typing_double_max_reduce_block))


@register
class _typing_uchar_min_reduce_block(ConcreteTemplate):
    key = globals()["uchar_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_min_reduce_block, types.Function(_typing_uchar_min_reduce_block))


@register
class _typing_ushort_min_reduce_block(ConcreteTemplate):
    key = globals()["ushort_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_min_reduce_block, types.Function(_typing_ushort_min_reduce_block))


@register
class _typing_uint_min_reduce_block(ConcreteTemplate):
    key = globals()["uint_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_min_reduce_block, types.Function(_typing_uint_min_reduce_block))


@register
class _typing_ulong_min_reduce_block(ConcreteTemplate):
    key = globals()["ulong_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_min_reduce_block, types.Function(_typing_ulong_min_reduce_block))


@register
class _typing_ulonglong_min_reduce_block(ConcreteTemplate):
    key = globals()["ulonglong_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_min_reduce_block, types.Function(_typing_ulonglong_min_reduce_block))


@register
class _typing_int8_min_reduce_block(ConcreteTemplate):
    key = globals()["int8_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_min_reduce_block, types.Function(_typing_int8_min_reduce_block))


@register
class _typing_int16_min_reduce_block(ConcreteTemplate):
    key = globals()["int16_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_min_reduce_block, types.Function(_typing_int16_min_reduce_block))


@register
class _typing_int32_min_reduce_block(ConcreteTemplate):
    key = globals()["int32_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_min_reduce_block, types.Function(_typing_int32_min_reduce_block))


@register
class _typing_int64_min_reduce_block(ConcreteTemplate):
    key = globals()["int64_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_min_reduce_block, types.Function(_typing_int64_min_reduce_block))


@register
class _typing_uint8_min_reduce_block(ConcreteTemplate):
    key = globals()["uint8_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_min_reduce_block, types.Function(_typing_uint8_min_reduce_block))


@register
class _typing_uint16_min_reduce_block(ConcreteTemplate):
    key = globals()["uint16_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_min_reduce_block, types.Function(_typing_uint16_min_reduce_block))


@register
class _typing_uint32_min_reduce_block(ConcreteTemplate):
    key = globals()["uint32_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_min_reduce_block, types.Function(_typing_uint32_min_reduce_block))


@register
class _typing_uint64_min_reduce_block(ConcreteTemplate):
    key = globals()["uint64_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_min_reduce_block, types.Function(_typing_uint64_min_reduce_block))


@register
class _typing_size_min_reduce_block(ConcreteTemplate):
    key = globals()["size_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_min_reduce_block, types.Function(_typing_size_min_reduce_block))


@register
class _typing_char_min_reduce_block(ConcreteTemplate):
    key = globals()["char_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_min_reduce_block, types.Function(_typing_char_min_reduce_block))


@register
class _typing_schar_min_reduce_block(ConcreteTemplate):
    key = globals()["schar_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_min_reduce_block, types.Function(_typing_schar_min_reduce_block))


@register
class _typing_short_min_reduce_block(ConcreteTemplate):
    key = globals()["short_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_min_reduce_block, types.Function(_typing_short_min_reduce_block))


@register
class _typing_int_min_reduce_block(ConcreteTemplate):
    key = globals()["int_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_min_reduce_block, types.Function(_typing_int_min_reduce_block))


@register
class _typing_long_min_reduce_block(ConcreteTemplate):
    key = globals()["long_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_min_reduce_block, types.Function(_typing_long_min_reduce_block))


@register
class _typing_longlong_min_reduce_block(ConcreteTemplate):
    key = globals()["longlong_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_min_reduce_block, types.Function(_typing_longlong_min_reduce_block))


@register
class _typing_bfloat16_min_reduce_block(ConcreteTemplate):
    key = globals()["bfloat16_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_min_reduce_block, types.Function(_typing_bfloat16_min_reduce_block))


@register
class _typing_half_min_reduce_block(ConcreteTemplate):
    key = globals()["half_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_min_reduce_block, types.Function(_typing_half_min_reduce_block))


@register
class _typing_float_min_reduce_block(ConcreteTemplate):
    key = globals()["float_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_min_reduce_block, types.Function(_typing_float_min_reduce_block))


@register
class _typing_double_min_reduce_block(ConcreteTemplate):
    key = globals()["double_min_reduce_block"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_min_reduce_block, types.Function(_typing_double_min_reduce_block))


@register
class _typing_uchar_sum_reduce_block(ConcreteTemplate):
    key = globals()["uchar_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_sum_reduce_block, types.Function(_typing_uchar_sum_reduce_block))


@register
class _typing_ushort_sum_reduce_block(ConcreteTemplate):
    key = globals()["ushort_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_sum_reduce_block, types.Function(_typing_ushort_sum_reduce_block))


@register
class _typing_uint_sum_reduce_block(ConcreteTemplate):
    key = globals()["uint_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_sum_reduce_block, types.Function(_typing_uint_sum_reduce_block))


@register
class _typing_ulong_sum_reduce_block(ConcreteTemplate):
    key = globals()["ulong_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_sum_reduce_block, types.Function(_typing_ulong_sum_reduce_block))


@register
class _typing_ulonglong_sum_reduce_block(ConcreteTemplate):
    key = globals()["ulonglong_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_sum_reduce_block, types.Function(_typing_ulonglong_sum_reduce_block))


@register
class _typing_int8_sum_reduce_block(ConcreteTemplate):
    key = globals()["int8_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_sum_reduce_block, types.Function(_typing_int8_sum_reduce_block))


@register
class _typing_int16_sum_reduce_block(ConcreteTemplate):
    key = globals()["int16_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_sum_reduce_block, types.Function(_typing_int16_sum_reduce_block))


@register
class _typing_int32_sum_reduce_block(ConcreteTemplate):
    key = globals()["int32_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_sum_reduce_block, types.Function(_typing_int32_sum_reduce_block))


@register
class _typing_int64_sum_reduce_block(ConcreteTemplate):
    key = globals()["int64_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_sum_reduce_block, types.Function(_typing_int64_sum_reduce_block))


@register
class _typing_uint8_sum_reduce_block(ConcreteTemplate):
    key = globals()["uint8_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_sum_reduce_block, types.Function(_typing_uint8_sum_reduce_block))


@register
class _typing_uint16_sum_reduce_block(ConcreteTemplate):
    key = globals()["uint16_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_sum_reduce_block, types.Function(_typing_uint16_sum_reduce_block))


@register
class _typing_uint32_sum_reduce_block(ConcreteTemplate):
    key = globals()["uint32_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_sum_reduce_block, types.Function(_typing_uint32_sum_reduce_block))


@register
class _typing_uint64_sum_reduce_block(ConcreteTemplate):
    key = globals()["uint64_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_sum_reduce_block, types.Function(_typing_uint64_sum_reduce_block))


@register
class _typing_size_sum_reduce_block(ConcreteTemplate):
    key = globals()["size_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_sum_reduce_block, types.Function(_typing_size_sum_reduce_block))


@register
class _typing_char_sum_reduce_block(ConcreteTemplate):
    key = globals()["char_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_sum_reduce_block, types.Function(_typing_char_sum_reduce_block))


@register
class _typing_schar_sum_reduce_block(ConcreteTemplate):
    key = globals()["schar_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_sum_reduce_block, types.Function(_typing_schar_sum_reduce_block))


@register
class _typing_short_sum_reduce_block(ConcreteTemplate):
    key = globals()["short_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_sum_reduce_block, types.Function(_typing_short_sum_reduce_block))


@register
class _typing_int_sum_reduce_block(ConcreteTemplate):
    key = globals()["int_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_sum_reduce_block, types.Function(_typing_int_sum_reduce_block))


@register
class _typing_long_sum_reduce_block(ConcreteTemplate):
    key = globals()["long_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_sum_reduce_block, types.Function(_typing_long_sum_reduce_block))


@register
class _typing_longlong_sum_reduce_block(ConcreteTemplate):
    key = globals()["longlong_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_sum_reduce_block, types.Function(_typing_longlong_sum_reduce_block))


@register
class _typing_bfloat16_sum_reduce_block(ConcreteTemplate):
    key = globals()["bfloat16_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_sum_reduce_block, types.Function(_typing_bfloat16_sum_reduce_block))


@register
class _typing_half_sum_reduce_block(ConcreteTemplate):
    key = globals()["half_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_sum_reduce_block, types.Function(_typing_half_sum_reduce_block))


@register
class _typing_float_sum_reduce_block(ConcreteTemplate):
    key = globals()["float_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_sum_reduce_block, types.Function(_typing_float_sum_reduce_block))


@register
class _typing_double_sum_reduce_block(ConcreteTemplate):
    key = globals()["double_sum_reduce_block"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_sum_reduce_block, types.Function(_typing_double_sum_reduce_block))


@register
class _typing_uchar_prod_reduce_block(ConcreteTemplate):
    key = globals()["uchar_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_prod_reduce_block, types.Function(_typing_uchar_prod_reduce_block))


@register
class _typing_ushort_prod_reduce_block(ConcreteTemplate):
    key = globals()["ushort_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_prod_reduce_block, types.Function(_typing_ushort_prod_reduce_block))


@register
class _typing_uint_prod_reduce_block(ConcreteTemplate):
    key = globals()["uint_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_prod_reduce_block, types.Function(_typing_uint_prod_reduce_block))


@register
class _typing_ulong_prod_reduce_block(ConcreteTemplate):
    key = globals()["ulong_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_prod_reduce_block, types.Function(_typing_ulong_prod_reduce_block))


@register
class _typing_ulonglong_prod_reduce_block(ConcreteTemplate):
    key = globals()["ulonglong_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_prod_reduce_block, types.Function(_typing_ulonglong_prod_reduce_block))


@register
class _typing_int8_prod_reduce_block(ConcreteTemplate):
    key = globals()["int8_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_prod_reduce_block, types.Function(_typing_int8_prod_reduce_block))


@register
class _typing_int16_prod_reduce_block(ConcreteTemplate):
    key = globals()["int16_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_prod_reduce_block, types.Function(_typing_int16_prod_reduce_block))


@register
class _typing_int32_prod_reduce_block(ConcreteTemplate):
    key = globals()["int32_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_prod_reduce_block, types.Function(_typing_int32_prod_reduce_block))


@register
class _typing_int64_prod_reduce_block(ConcreteTemplate):
    key = globals()["int64_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_prod_reduce_block, types.Function(_typing_int64_prod_reduce_block))


@register
class _typing_uint8_prod_reduce_block(ConcreteTemplate):
    key = globals()["uint8_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_prod_reduce_block, types.Function(_typing_uint8_prod_reduce_block))


@register
class _typing_uint16_prod_reduce_block(ConcreteTemplate):
    key = globals()["uint16_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_prod_reduce_block, types.Function(_typing_uint16_prod_reduce_block))


@register
class _typing_uint32_prod_reduce_block(ConcreteTemplate):
    key = globals()["uint32_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_prod_reduce_block, types.Function(_typing_uint32_prod_reduce_block))


@register
class _typing_uint64_prod_reduce_block(ConcreteTemplate):
    key = globals()["uint64_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_prod_reduce_block, types.Function(_typing_uint64_prod_reduce_block))


@register
class _typing_size_prod_reduce_block(ConcreteTemplate):
    key = globals()["size_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_prod_reduce_block, types.Function(_typing_size_prod_reduce_block))


@register
class _typing_char_prod_reduce_block(ConcreteTemplate):
    key = globals()["char_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_prod_reduce_block, types.Function(_typing_char_prod_reduce_block))


@register
class _typing_schar_prod_reduce_block(ConcreteTemplate):
    key = globals()["schar_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_prod_reduce_block, types.Function(_typing_schar_prod_reduce_block))


@register
class _typing_short_prod_reduce_block(ConcreteTemplate):
    key = globals()["short_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_prod_reduce_block, types.Function(_typing_short_prod_reduce_block))


@register
class _typing_int_prod_reduce_block(ConcreteTemplate):
    key = globals()["int_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_prod_reduce_block, types.Function(_typing_int_prod_reduce_block))


@register
class _typing_long_prod_reduce_block(ConcreteTemplate):
    key = globals()["long_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_prod_reduce_block, types.Function(_typing_long_prod_reduce_block))


@register
class _typing_longlong_prod_reduce_block(ConcreteTemplate):
    key = globals()["longlong_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_prod_reduce_block, types.Function(_typing_longlong_prod_reduce_block))


@register
class _typing_bfloat16_prod_reduce_block(ConcreteTemplate):
    key = globals()["bfloat16_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_prod_reduce_block, types.Function(_typing_bfloat16_prod_reduce_block))


@register
class _typing_half_prod_reduce_block(ConcreteTemplate):
    key = globals()["half_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_prod_reduce_block, types.Function(_typing_half_prod_reduce_block))


@register
class _typing_float_prod_reduce_block(ConcreteTemplate):
    key = globals()["float_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_prod_reduce_block, types.Function(_typing_float_prod_reduce_block))


@register
class _typing_double_prod_reduce_block(ConcreteTemplate):
    key = globals()["double_prod_reduce_block"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_prod_reduce_block, types.Function(_typing_double_prod_reduce_block))


@register
class _typing_uchar_and_reducescatter_warp(ConcreteTemplate):
    key = globals()["uchar_and_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_and_reducescatter_warp, types.Function(_typing_uchar_and_reducescatter_warp))


@register
class _typing_ushort_and_reducescatter_warp(ConcreteTemplate):
    key = globals()["ushort_and_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_and_reducescatter_warp, types.Function(_typing_ushort_and_reducescatter_warp))


@register
class _typing_uint_and_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint_and_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_and_reducescatter_warp, types.Function(_typing_uint_and_reducescatter_warp))


@register
class _typing_ulong_and_reducescatter_warp(ConcreteTemplate):
    key = globals()["ulong_and_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_and_reducescatter_warp, types.Function(_typing_ulong_and_reducescatter_warp))


@register
class _typing_ulonglong_and_reducescatter_warp(ConcreteTemplate):
    key = globals()["ulonglong_and_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_and_reducescatter_warp, types.Function(_typing_ulonglong_and_reducescatter_warp))


@register
class _typing_int8_and_reducescatter_warp(ConcreteTemplate):
    key = globals()["int8_and_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_and_reducescatter_warp, types.Function(_typing_int8_and_reducescatter_warp))


@register
class _typing_int16_and_reducescatter_warp(ConcreteTemplate):
    key = globals()["int16_and_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_and_reducescatter_warp, types.Function(_typing_int16_and_reducescatter_warp))


@register
class _typing_int32_and_reducescatter_warp(ConcreteTemplate):
    key = globals()["int32_and_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_and_reducescatter_warp, types.Function(_typing_int32_and_reducescatter_warp))


@register
class _typing_int64_and_reducescatter_warp(ConcreteTemplate):
    key = globals()["int64_and_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_and_reducescatter_warp, types.Function(_typing_int64_and_reducescatter_warp))


@register
class _typing_uint8_and_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint8_and_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_and_reducescatter_warp, types.Function(_typing_uint8_and_reducescatter_warp))


@register
class _typing_uint16_and_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint16_and_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_and_reducescatter_warp, types.Function(_typing_uint16_and_reducescatter_warp))


@register
class _typing_uint32_and_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint32_and_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_and_reducescatter_warp, types.Function(_typing_uint32_and_reducescatter_warp))


@register
class _typing_uint64_and_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint64_and_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_and_reducescatter_warp, types.Function(_typing_uint64_and_reducescatter_warp))


@register
class _typing_size_and_reducescatter_warp(ConcreteTemplate):
    key = globals()["size_and_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_and_reducescatter_warp, types.Function(_typing_size_and_reducescatter_warp))


@register
class _typing_uchar_or_reducescatter_warp(ConcreteTemplate):
    key = globals()["uchar_or_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_or_reducescatter_warp, types.Function(_typing_uchar_or_reducescatter_warp))


@register
class _typing_ushort_or_reducescatter_warp(ConcreteTemplate):
    key = globals()["ushort_or_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_or_reducescatter_warp, types.Function(_typing_ushort_or_reducescatter_warp))


@register
class _typing_uint_or_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint_or_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_or_reducescatter_warp, types.Function(_typing_uint_or_reducescatter_warp))


@register
class _typing_ulong_or_reducescatter_warp(ConcreteTemplate):
    key = globals()["ulong_or_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_or_reducescatter_warp, types.Function(_typing_ulong_or_reducescatter_warp))


@register
class _typing_ulonglong_or_reducescatter_warp(ConcreteTemplate):
    key = globals()["ulonglong_or_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_or_reducescatter_warp, types.Function(_typing_ulonglong_or_reducescatter_warp))


@register
class _typing_int8_or_reducescatter_warp(ConcreteTemplate):
    key = globals()["int8_or_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_or_reducescatter_warp, types.Function(_typing_int8_or_reducescatter_warp))


@register
class _typing_int16_or_reducescatter_warp(ConcreteTemplate):
    key = globals()["int16_or_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_or_reducescatter_warp, types.Function(_typing_int16_or_reducescatter_warp))


@register
class _typing_int32_or_reducescatter_warp(ConcreteTemplate):
    key = globals()["int32_or_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_or_reducescatter_warp, types.Function(_typing_int32_or_reducescatter_warp))


@register
class _typing_int64_or_reducescatter_warp(ConcreteTemplate):
    key = globals()["int64_or_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_or_reducescatter_warp, types.Function(_typing_int64_or_reducescatter_warp))


@register
class _typing_uint8_or_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint8_or_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_or_reducescatter_warp, types.Function(_typing_uint8_or_reducescatter_warp))


@register
class _typing_uint16_or_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint16_or_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_or_reducescatter_warp, types.Function(_typing_uint16_or_reducescatter_warp))


@register
class _typing_uint32_or_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint32_or_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_or_reducescatter_warp, types.Function(_typing_uint32_or_reducescatter_warp))


@register
class _typing_uint64_or_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint64_or_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_or_reducescatter_warp, types.Function(_typing_uint64_or_reducescatter_warp))


@register
class _typing_size_or_reducescatter_warp(ConcreteTemplate):
    key = globals()["size_or_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_or_reducescatter_warp, types.Function(_typing_size_or_reducescatter_warp))


@register
class _typing_uchar_xor_reducescatter_warp(ConcreteTemplate):
    key = globals()["uchar_xor_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_xor_reducescatter_warp, types.Function(_typing_uchar_xor_reducescatter_warp))


@register
class _typing_ushort_xor_reducescatter_warp(ConcreteTemplate):
    key = globals()["ushort_xor_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_xor_reducescatter_warp, types.Function(_typing_ushort_xor_reducescatter_warp))


@register
class _typing_uint_xor_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint_xor_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_xor_reducescatter_warp, types.Function(_typing_uint_xor_reducescatter_warp))


@register
class _typing_ulong_xor_reducescatter_warp(ConcreteTemplate):
    key = globals()["ulong_xor_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_xor_reducescatter_warp, types.Function(_typing_ulong_xor_reducescatter_warp))


@register
class _typing_ulonglong_xor_reducescatter_warp(ConcreteTemplate):
    key = globals()["ulonglong_xor_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_xor_reducescatter_warp, types.Function(_typing_ulonglong_xor_reducescatter_warp))


@register
class _typing_int8_xor_reducescatter_warp(ConcreteTemplate):
    key = globals()["int8_xor_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_xor_reducescatter_warp, types.Function(_typing_int8_xor_reducescatter_warp))


@register
class _typing_int16_xor_reducescatter_warp(ConcreteTemplate):
    key = globals()["int16_xor_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_xor_reducescatter_warp, types.Function(_typing_int16_xor_reducescatter_warp))


@register
class _typing_int32_xor_reducescatter_warp(ConcreteTemplate):
    key = globals()["int32_xor_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_xor_reducescatter_warp, types.Function(_typing_int32_xor_reducescatter_warp))


@register
class _typing_int64_xor_reducescatter_warp(ConcreteTemplate):
    key = globals()["int64_xor_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_xor_reducescatter_warp, types.Function(_typing_int64_xor_reducescatter_warp))


@register
class _typing_uint8_xor_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint8_xor_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_xor_reducescatter_warp, types.Function(_typing_uint8_xor_reducescatter_warp))


@register
class _typing_uint16_xor_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint16_xor_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_xor_reducescatter_warp, types.Function(_typing_uint16_xor_reducescatter_warp))


@register
class _typing_uint32_xor_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint32_xor_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_xor_reducescatter_warp, types.Function(_typing_uint32_xor_reducescatter_warp))


@register
class _typing_uint64_xor_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint64_xor_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_xor_reducescatter_warp, types.Function(_typing_uint64_xor_reducescatter_warp))


@register
class _typing_size_xor_reducescatter_warp(ConcreteTemplate):
    key = globals()["size_xor_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_xor_reducescatter_warp, types.Function(_typing_size_xor_reducescatter_warp))


@register
class _typing_uchar_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["uchar_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_max_reducescatter_warp, types.Function(_typing_uchar_max_reducescatter_warp))


@register
class _typing_ushort_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["ushort_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_max_reducescatter_warp, types.Function(_typing_ushort_max_reducescatter_warp))


@register
class _typing_uint_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_max_reducescatter_warp, types.Function(_typing_uint_max_reducescatter_warp))


@register
class _typing_ulong_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["ulong_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_max_reducescatter_warp, types.Function(_typing_ulong_max_reducescatter_warp))


@register
class _typing_ulonglong_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["ulonglong_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_max_reducescatter_warp, types.Function(_typing_ulonglong_max_reducescatter_warp))


@register
class _typing_int8_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["int8_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_max_reducescatter_warp, types.Function(_typing_int8_max_reducescatter_warp))


@register
class _typing_int16_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["int16_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_max_reducescatter_warp, types.Function(_typing_int16_max_reducescatter_warp))


@register
class _typing_int32_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["int32_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_max_reducescatter_warp, types.Function(_typing_int32_max_reducescatter_warp))


@register
class _typing_int64_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["int64_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_max_reducescatter_warp, types.Function(_typing_int64_max_reducescatter_warp))


@register
class _typing_uint8_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint8_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_max_reducescatter_warp, types.Function(_typing_uint8_max_reducescatter_warp))


@register
class _typing_uint16_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint16_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_max_reducescatter_warp, types.Function(_typing_uint16_max_reducescatter_warp))


@register
class _typing_uint32_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint32_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_max_reducescatter_warp, types.Function(_typing_uint32_max_reducescatter_warp))


@register
class _typing_uint64_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint64_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_max_reducescatter_warp, types.Function(_typing_uint64_max_reducescatter_warp))


@register
class _typing_size_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["size_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_max_reducescatter_warp, types.Function(_typing_size_max_reducescatter_warp))


@register
class _typing_char_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["char_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_max_reducescatter_warp, types.Function(_typing_char_max_reducescatter_warp))


@register
class _typing_schar_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["schar_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_max_reducescatter_warp, types.Function(_typing_schar_max_reducescatter_warp))


@register
class _typing_short_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["short_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_max_reducescatter_warp, types.Function(_typing_short_max_reducescatter_warp))


@register
class _typing_int_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["int_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_max_reducescatter_warp, types.Function(_typing_int_max_reducescatter_warp))


@register
class _typing_long_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["long_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_max_reducescatter_warp, types.Function(_typing_long_max_reducescatter_warp))


@register
class _typing_longlong_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["longlong_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_max_reducescatter_warp, types.Function(_typing_longlong_max_reducescatter_warp))


@register
class _typing_bfloat16_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["bfloat16_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_max_reducescatter_warp, types.Function(_typing_bfloat16_max_reducescatter_warp))


@register
class _typing_half_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["half_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_max_reducescatter_warp, types.Function(_typing_half_max_reducescatter_warp))


@register
class _typing_float_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["float_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_max_reducescatter_warp, types.Function(_typing_float_max_reducescatter_warp))


@register
class _typing_double_max_reducescatter_warp(ConcreteTemplate):
    key = globals()["double_max_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_max_reducescatter_warp, types.Function(_typing_double_max_reducescatter_warp))


@register
class _typing_uchar_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["uchar_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_min_reducescatter_warp, types.Function(_typing_uchar_min_reducescatter_warp))


@register
class _typing_ushort_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["ushort_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_min_reducescatter_warp, types.Function(_typing_ushort_min_reducescatter_warp))


@register
class _typing_uint_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_min_reducescatter_warp, types.Function(_typing_uint_min_reducescatter_warp))


@register
class _typing_ulong_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["ulong_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_min_reducescatter_warp, types.Function(_typing_ulong_min_reducescatter_warp))


@register
class _typing_ulonglong_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["ulonglong_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_min_reducescatter_warp, types.Function(_typing_ulonglong_min_reducescatter_warp))


@register
class _typing_int8_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["int8_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_min_reducescatter_warp, types.Function(_typing_int8_min_reducescatter_warp))


@register
class _typing_int16_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["int16_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_min_reducescatter_warp, types.Function(_typing_int16_min_reducescatter_warp))


@register
class _typing_int32_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["int32_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_min_reducescatter_warp, types.Function(_typing_int32_min_reducescatter_warp))


@register
class _typing_int64_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["int64_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_min_reducescatter_warp, types.Function(_typing_int64_min_reducescatter_warp))


@register
class _typing_uint8_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint8_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_min_reducescatter_warp, types.Function(_typing_uint8_min_reducescatter_warp))


@register
class _typing_uint16_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint16_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_min_reducescatter_warp, types.Function(_typing_uint16_min_reducescatter_warp))


@register
class _typing_uint32_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint32_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_min_reducescatter_warp, types.Function(_typing_uint32_min_reducescatter_warp))


@register
class _typing_uint64_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint64_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_min_reducescatter_warp, types.Function(_typing_uint64_min_reducescatter_warp))


@register
class _typing_size_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["size_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_min_reducescatter_warp, types.Function(_typing_size_min_reducescatter_warp))


@register
class _typing_char_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["char_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_min_reducescatter_warp, types.Function(_typing_char_min_reducescatter_warp))


@register
class _typing_schar_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["schar_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_min_reducescatter_warp, types.Function(_typing_schar_min_reducescatter_warp))


@register
class _typing_short_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["short_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_min_reducescatter_warp, types.Function(_typing_short_min_reducescatter_warp))


@register
class _typing_int_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["int_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_min_reducescatter_warp, types.Function(_typing_int_min_reducescatter_warp))


@register
class _typing_long_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["long_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_min_reducescatter_warp, types.Function(_typing_long_min_reducescatter_warp))


@register
class _typing_longlong_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["longlong_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_min_reducescatter_warp, types.Function(_typing_longlong_min_reducescatter_warp))


@register
class _typing_bfloat16_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["bfloat16_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_min_reducescatter_warp, types.Function(_typing_bfloat16_min_reducescatter_warp))


@register
class _typing_half_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["half_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_min_reducescatter_warp, types.Function(_typing_half_min_reducescatter_warp))


@register
class _typing_float_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["float_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_min_reducescatter_warp, types.Function(_typing_float_min_reducescatter_warp))


@register
class _typing_double_min_reducescatter_warp(ConcreteTemplate):
    key = globals()["double_min_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_min_reducescatter_warp, types.Function(_typing_double_min_reducescatter_warp))


@register
class _typing_uchar_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["uchar_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_sum_reducescatter_warp, types.Function(_typing_uchar_sum_reducescatter_warp))


@register
class _typing_ushort_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["ushort_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_sum_reducescatter_warp, types.Function(_typing_ushort_sum_reducescatter_warp))


@register
class _typing_uint_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_sum_reducescatter_warp, types.Function(_typing_uint_sum_reducescatter_warp))


@register
class _typing_ulong_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["ulong_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_sum_reducescatter_warp, types.Function(_typing_ulong_sum_reducescatter_warp))


@register
class _typing_ulonglong_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["ulonglong_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_sum_reducescatter_warp, types.Function(_typing_ulonglong_sum_reducescatter_warp))


@register
class _typing_int8_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["int8_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_sum_reducescatter_warp, types.Function(_typing_int8_sum_reducescatter_warp))


@register
class _typing_int16_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["int16_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_sum_reducescatter_warp, types.Function(_typing_int16_sum_reducescatter_warp))


@register
class _typing_int32_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["int32_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_sum_reducescatter_warp, types.Function(_typing_int32_sum_reducescatter_warp))


@register
class _typing_int64_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["int64_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_sum_reducescatter_warp, types.Function(_typing_int64_sum_reducescatter_warp))


@register
class _typing_uint8_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint8_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_sum_reducescatter_warp, types.Function(_typing_uint8_sum_reducescatter_warp))


@register
class _typing_uint16_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint16_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_sum_reducescatter_warp, types.Function(_typing_uint16_sum_reducescatter_warp))


@register
class _typing_uint32_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint32_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_sum_reducescatter_warp, types.Function(_typing_uint32_sum_reducescatter_warp))


@register
class _typing_uint64_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint64_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_sum_reducescatter_warp, types.Function(_typing_uint64_sum_reducescatter_warp))


@register
class _typing_size_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["size_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_sum_reducescatter_warp, types.Function(_typing_size_sum_reducescatter_warp))


@register
class _typing_char_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["char_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_sum_reducescatter_warp, types.Function(_typing_char_sum_reducescatter_warp))


@register
class _typing_schar_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["schar_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_sum_reducescatter_warp, types.Function(_typing_schar_sum_reducescatter_warp))


@register
class _typing_short_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["short_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_sum_reducescatter_warp, types.Function(_typing_short_sum_reducescatter_warp))


@register
class _typing_int_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["int_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_sum_reducescatter_warp, types.Function(_typing_int_sum_reducescatter_warp))


@register
class _typing_long_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["long_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_sum_reducescatter_warp, types.Function(_typing_long_sum_reducescatter_warp))


@register
class _typing_longlong_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["longlong_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_sum_reducescatter_warp, types.Function(_typing_longlong_sum_reducescatter_warp))


@register
class _typing_bfloat16_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["bfloat16_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_sum_reducescatter_warp, types.Function(_typing_bfloat16_sum_reducescatter_warp))


@register
class _typing_half_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["half_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_sum_reducescatter_warp, types.Function(_typing_half_sum_reducescatter_warp))


@register
class _typing_float_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["float_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_sum_reducescatter_warp, types.Function(_typing_float_sum_reducescatter_warp))


@register
class _typing_double_sum_reducescatter_warp(ConcreteTemplate):
    key = globals()["double_sum_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_sum_reducescatter_warp, types.Function(_typing_double_sum_reducescatter_warp))


@register
class _typing_uchar_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["uchar_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_prod_reducescatter_warp, types.Function(_typing_uchar_prod_reducescatter_warp))


@register
class _typing_ushort_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["ushort_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_prod_reducescatter_warp, types.Function(_typing_ushort_prod_reducescatter_warp))


@register
class _typing_uint_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_prod_reducescatter_warp, types.Function(_typing_uint_prod_reducescatter_warp))


@register
class _typing_ulong_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["ulong_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_prod_reducescatter_warp, types.Function(_typing_ulong_prod_reducescatter_warp))


@register
class _typing_ulonglong_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["ulonglong_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_prod_reducescatter_warp, types.Function(_typing_ulonglong_prod_reducescatter_warp))


@register
class _typing_int8_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["int8_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_prod_reducescatter_warp, types.Function(_typing_int8_prod_reducescatter_warp))


@register
class _typing_int16_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["int16_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_prod_reducescatter_warp, types.Function(_typing_int16_prod_reducescatter_warp))


@register
class _typing_int32_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["int32_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_prod_reducescatter_warp, types.Function(_typing_int32_prod_reducescatter_warp))


@register
class _typing_int64_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["int64_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_prod_reducescatter_warp, types.Function(_typing_int64_prod_reducescatter_warp))


@register
class _typing_uint8_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint8_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_prod_reducescatter_warp, types.Function(_typing_uint8_prod_reducescatter_warp))


@register
class _typing_uint16_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint16_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_prod_reducescatter_warp, types.Function(_typing_uint16_prod_reducescatter_warp))


@register
class _typing_uint32_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint32_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_prod_reducescatter_warp, types.Function(_typing_uint32_prod_reducescatter_warp))


@register
class _typing_uint64_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["uint64_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_prod_reducescatter_warp, types.Function(_typing_uint64_prod_reducescatter_warp))


@register
class _typing_size_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["size_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_prod_reducescatter_warp, types.Function(_typing_size_prod_reducescatter_warp))


@register
class _typing_char_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["char_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_prod_reducescatter_warp, types.Function(_typing_char_prod_reducescatter_warp))


@register
class _typing_schar_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["schar_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_prod_reducescatter_warp, types.Function(_typing_schar_prod_reducescatter_warp))


@register
class _typing_short_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["short_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_prod_reducescatter_warp, types.Function(_typing_short_prod_reducescatter_warp))


@register
class _typing_int_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["int_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_prod_reducescatter_warp, types.Function(_typing_int_prod_reducescatter_warp))


@register
class _typing_long_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["long_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_prod_reducescatter_warp, types.Function(_typing_long_prod_reducescatter_warp))


@register
class _typing_longlong_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["longlong_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_prod_reducescatter_warp, types.Function(_typing_longlong_prod_reducescatter_warp))


@register
class _typing_bfloat16_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["bfloat16_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_prod_reducescatter_warp, types.Function(_typing_bfloat16_prod_reducescatter_warp))


@register
class _typing_half_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["half_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_prod_reducescatter_warp, types.Function(_typing_half_prod_reducescatter_warp))


@register
class _typing_float_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["float_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_prod_reducescatter_warp, types.Function(_typing_float_prod_reducescatter_warp))


@register
class _typing_double_prod_reducescatter_warp(ConcreteTemplate):
    key = globals()["double_prod_reducescatter_warp"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_prod_reducescatter_warp, types.Function(_typing_double_prod_reducescatter_warp))


@register
class _typing_uchar_and_reducescatter_block(ConcreteTemplate):
    key = globals()["uchar_and_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_and_reducescatter_block, types.Function(_typing_uchar_and_reducescatter_block))


@register
class _typing_ushort_and_reducescatter_block(ConcreteTemplate):
    key = globals()["ushort_and_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_and_reducescatter_block, types.Function(_typing_ushort_and_reducescatter_block))


@register
class _typing_uint_and_reducescatter_block(ConcreteTemplate):
    key = globals()["uint_and_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_and_reducescatter_block, types.Function(_typing_uint_and_reducescatter_block))


@register
class _typing_ulong_and_reducescatter_block(ConcreteTemplate):
    key = globals()["ulong_and_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_and_reducescatter_block, types.Function(_typing_ulong_and_reducescatter_block))


@register
class _typing_ulonglong_and_reducescatter_block(ConcreteTemplate):
    key = globals()["ulonglong_and_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_and_reducescatter_block, types.Function(_typing_ulonglong_and_reducescatter_block))


@register
class _typing_int8_and_reducescatter_block(ConcreteTemplate):
    key = globals()["int8_and_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_and_reducescatter_block, types.Function(_typing_int8_and_reducescatter_block))


@register
class _typing_int16_and_reducescatter_block(ConcreteTemplate):
    key = globals()["int16_and_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_and_reducescatter_block, types.Function(_typing_int16_and_reducescatter_block))


@register
class _typing_int32_and_reducescatter_block(ConcreteTemplate):
    key = globals()["int32_and_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_and_reducescatter_block, types.Function(_typing_int32_and_reducescatter_block))


@register
class _typing_int64_and_reducescatter_block(ConcreteTemplate):
    key = globals()["int64_and_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_and_reducescatter_block, types.Function(_typing_int64_and_reducescatter_block))


@register
class _typing_uint8_and_reducescatter_block(ConcreteTemplate):
    key = globals()["uint8_and_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_and_reducescatter_block, types.Function(_typing_uint8_and_reducescatter_block))


@register
class _typing_uint16_and_reducescatter_block(ConcreteTemplate):
    key = globals()["uint16_and_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_and_reducescatter_block, types.Function(_typing_uint16_and_reducescatter_block))


@register
class _typing_uint32_and_reducescatter_block(ConcreteTemplate):
    key = globals()["uint32_and_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_and_reducescatter_block, types.Function(_typing_uint32_and_reducescatter_block))


@register
class _typing_uint64_and_reducescatter_block(ConcreteTemplate):
    key = globals()["uint64_and_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_and_reducescatter_block, types.Function(_typing_uint64_and_reducescatter_block))


@register
class _typing_size_and_reducescatter_block(ConcreteTemplate):
    key = globals()["size_and_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_and_reducescatter_block, types.Function(_typing_size_and_reducescatter_block))


@register
class _typing_uchar_or_reducescatter_block(ConcreteTemplate):
    key = globals()["uchar_or_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_or_reducescatter_block, types.Function(_typing_uchar_or_reducescatter_block))


@register
class _typing_ushort_or_reducescatter_block(ConcreteTemplate):
    key = globals()["ushort_or_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_or_reducescatter_block, types.Function(_typing_ushort_or_reducescatter_block))


@register
class _typing_uint_or_reducescatter_block(ConcreteTemplate):
    key = globals()["uint_or_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_or_reducescatter_block, types.Function(_typing_uint_or_reducescatter_block))


@register
class _typing_ulong_or_reducescatter_block(ConcreteTemplate):
    key = globals()["ulong_or_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_or_reducescatter_block, types.Function(_typing_ulong_or_reducescatter_block))


@register
class _typing_ulonglong_or_reducescatter_block(ConcreteTemplate):
    key = globals()["ulonglong_or_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_or_reducescatter_block, types.Function(_typing_ulonglong_or_reducescatter_block))


@register
class _typing_int8_or_reducescatter_block(ConcreteTemplate):
    key = globals()["int8_or_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_or_reducescatter_block, types.Function(_typing_int8_or_reducescatter_block))


@register
class _typing_int16_or_reducescatter_block(ConcreteTemplate):
    key = globals()["int16_or_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_or_reducescatter_block, types.Function(_typing_int16_or_reducescatter_block))


@register
class _typing_int32_or_reducescatter_block(ConcreteTemplate):
    key = globals()["int32_or_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_or_reducescatter_block, types.Function(_typing_int32_or_reducescatter_block))


@register
class _typing_int64_or_reducescatter_block(ConcreteTemplate):
    key = globals()["int64_or_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_or_reducescatter_block, types.Function(_typing_int64_or_reducescatter_block))


@register
class _typing_uint8_or_reducescatter_block(ConcreteTemplate):
    key = globals()["uint8_or_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_or_reducescatter_block, types.Function(_typing_uint8_or_reducescatter_block))


@register
class _typing_uint16_or_reducescatter_block(ConcreteTemplate):
    key = globals()["uint16_or_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_or_reducescatter_block, types.Function(_typing_uint16_or_reducescatter_block))


@register
class _typing_uint32_or_reducescatter_block(ConcreteTemplate):
    key = globals()["uint32_or_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_or_reducescatter_block, types.Function(_typing_uint32_or_reducescatter_block))


@register
class _typing_uint64_or_reducescatter_block(ConcreteTemplate):
    key = globals()["uint64_or_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_or_reducescatter_block, types.Function(_typing_uint64_or_reducescatter_block))


@register
class _typing_size_or_reducescatter_block(ConcreteTemplate):
    key = globals()["size_or_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_or_reducescatter_block, types.Function(_typing_size_or_reducescatter_block))


@register
class _typing_uchar_xor_reducescatter_block(ConcreteTemplate):
    key = globals()["uchar_xor_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_xor_reducescatter_block, types.Function(_typing_uchar_xor_reducescatter_block))


@register
class _typing_ushort_xor_reducescatter_block(ConcreteTemplate):
    key = globals()["ushort_xor_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_xor_reducescatter_block, types.Function(_typing_ushort_xor_reducescatter_block))


@register
class _typing_uint_xor_reducescatter_block(ConcreteTemplate):
    key = globals()["uint_xor_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_xor_reducescatter_block, types.Function(_typing_uint_xor_reducescatter_block))


@register
class _typing_ulong_xor_reducescatter_block(ConcreteTemplate):
    key = globals()["ulong_xor_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_xor_reducescatter_block, types.Function(_typing_ulong_xor_reducescatter_block))


@register
class _typing_ulonglong_xor_reducescatter_block(ConcreteTemplate):
    key = globals()["ulonglong_xor_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_xor_reducescatter_block, types.Function(_typing_ulonglong_xor_reducescatter_block))


@register
class _typing_int8_xor_reducescatter_block(ConcreteTemplate):
    key = globals()["int8_xor_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_xor_reducescatter_block, types.Function(_typing_int8_xor_reducescatter_block))


@register
class _typing_int16_xor_reducescatter_block(ConcreteTemplate):
    key = globals()["int16_xor_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_xor_reducescatter_block, types.Function(_typing_int16_xor_reducescatter_block))


@register
class _typing_int32_xor_reducescatter_block(ConcreteTemplate):
    key = globals()["int32_xor_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_xor_reducescatter_block, types.Function(_typing_int32_xor_reducescatter_block))


@register
class _typing_int64_xor_reducescatter_block(ConcreteTemplate):
    key = globals()["int64_xor_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_xor_reducescatter_block, types.Function(_typing_int64_xor_reducescatter_block))


@register
class _typing_uint8_xor_reducescatter_block(ConcreteTemplate):
    key = globals()["uint8_xor_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_xor_reducescatter_block, types.Function(_typing_uint8_xor_reducescatter_block))


@register
class _typing_uint16_xor_reducescatter_block(ConcreteTemplate):
    key = globals()["uint16_xor_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_xor_reducescatter_block, types.Function(_typing_uint16_xor_reducescatter_block))


@register
class _typing_uint32_xor_reducescatter_block(ConcreteTemplate):
    key = globals()["uint32_xor_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_xor_reducescatter_block, types.Function(_typing_uint32_xor_reducescatter_block))


@register
class _typing_uint64_xor_reducescatter_block(ConcreteTemplate):
    key = globals()["uint64_xor_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_xor_reducescatter_block, types.Function(_typing_uint64_xor_reducescatter_block))


@register
class _typing_size_xor_reducescatter_block(ConcreteTemplate):
    key = globals()["size_xor_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_xor_reducescatter_block, types.Function(_typing_size_xor_reducescatter_block))


@register
class _typing_uchar_max_reducescatter_block(ConcreteTemplate):
    key = globals()["uchar_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_max_reducescatter_block, types.Function(_typing_uchar_max_reducescatter_block))


@register
class _typing_ushort_max_reducescatter_block(ConcreteTemplate):
    key = globals()["ushort_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_max_reducescatter_block, types.Function(_typing_ushort_max_reducescatter_block))


@register
class _typing_uint_max_reducescatter_block(ConcreteTemplate):
    key = globals()["uint_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_max_reducescatter_block, types.Function(_typing_uint_max_reducescatter_block))


@register
class _typing_ulong_max_reducescatter_block(ConcreteTemplate):
    key = globals()["ulong_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_max_reducescatter_block, types.Function(_typing_ulong_max_reducescatter_block))


@register
class _typing_ulonglong_max_reducescatter_block(ConcreteTemplate):
    key = globals()["ulonglong_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_max_reducescatter_block, types.Function(_typing_ulonglong_max_reducescatter_block))


@register
class _typing_int8_max_reducescatter_block(ConcreteTemplate):
    key = globals()["int8_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_max_reducescatter_block, types.Function(_typing_int8_max_reducescatter_block))


@register
class _typing_int16_max_reducescatter_block(ConcreteTemplate):
    key = globals()["int16_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_max_reducescatter_block, types.Function(_typing_int16_max_reducescatter_block))


@register
class _typing_int32_max_reducescatter_block(ConcreteTemplate):
    key = globals()["int32_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_max_reducescatter_block, types.Function(_typing_int32_max_reducescatter_block))


@register
class _typing_int64_max_reducescatter_block(ConcreteTemplate):
    key = globals()["int64_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_max_reducescatter_block, types.Function(_typing_int64_max_reducescatter_block))


@register
class _typing_uint8_max_reducescatter_block(ConcreteTemplate):
    key = globals()["uint8_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_max_reducescatter_block, types.Function(_typing_uint8_max_reducescatter_block))


@register
class _typing_uint16_max_reducescatter_block(ConcreteTemplate):
    key = globals()["uint16_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_max_reducescatter_block, types.Function(_typing_uint16_max_reducescatter_block))


@register
class _typing_uint32_max_reducescatter_block(ConcreteTemplate):
    key = globals()["uint32_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_max_reducescatter_block, types.Function(_typing_uint32_max_reducescatter_block))


@register
class _typing_uint64_max_reducescatter_block(ConcreteTemplate):
    key = globals()["uint64_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_max_reducescatter_block, types.Function(_typing_uint64_max_reducescatter_block))


@register
class _typing_size_max_reducescatter_block(ConcreteTemplate):
    key = globals()["size_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_max_reducescatter_block, types.Function(_typing_size_max_reducescatter_block))


@register
class _typing_char_max_reducescatter_block(ConcreteTemplate):
    key = globals()["char_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_max_reducescatter_block, types.Function(_typing_char_max_reducescatter_block))


@register
class _typing_schar_max_reducescatter_block(ConcreteTemplate):
    key = globals()["schar_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_max_reducescatter_block, types.Function(_typing_schar_max_reducescatter_block))


@register
class _typing_short_max_reducescatter_block(ConcreteTemplate):
    key = globals()["short_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_max_reducescatter_block, types.Function(_typing_short_max_reducescatter_block))


@register
class _typing_int_max_reducescatter_block(ConcreteTemplate):
    key = globals()["int_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_max_reducescatter_block, types.Function(_typing_int_max_reducescatter_block))


@register
class _typing_long_max_reducescatter_block(ConcreteTemplate):
    key = globals()["long_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_max_reducescatter_block, types.Function(_typing_long_max_reducescatter_block))


@register
class _typing_longlong_max_reducescatter_block(ConcreteTemplate):
    key = globals()["longlong_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_max_reducescatter_block, types.Function(_typing_longlong_max_reducescatter_block))


@register
class _typing_bfloat16_max_reducescatter_block(ConcreteTemplate):
    key = globals()["bfloat16_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_max_reducescatter_block, types.Function(_typing_bfloat16_max_reducescatter_block))


@register
class _typing_half_max_reducescatter_block(ConcreteTemplate):
    key = globals()["half_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_max_reducescatter_block, types.Function(_typing_half_max_reducescatter_block))


@register
class _typing_float_max_reducescatter_block(ConcreteTemplate):
    key = globals()["float_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_max_reducescatter_block, types.Function(_typing_float_max_reducescatter_block))


@register
class _typing_double_max_reducescatter_block(ConcreteTemplate):
    key = globals()["double_max_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_max_reducescatter_block, types.Function(_typing_double_max_reducescatter_block))


@register
class _typing_uchar_min_reducescatter_block(ConcreteTemplate):
    key = globals()["uchar_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_min_reducescatter_block, types.Function(_typing_uchar_min_reducescatter_block))


@register
class _typing_ushort_min_reducescatter_block(ConcreteTemplate):
    key = globals()["ushort_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_min_reducescatter_block, types.Function(_typing_ushort_min_reducescatter_block))


@register
class _typing_uint_min_reducescatter_block(ConcreteTemplate):
    key = globals()["uint_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_min_reducescatter_block, types.Function(_typing_uint_min_reducescatter_block))


@register
class _typing_ulong_min_reducescatter_block(ConcreteTemplate):
    key = globals()["ulong_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_min_reducescatter_block, types.Function(_typing_ulong_min_reducescatter_block))


@register
class _typing_ulonglong_min_reducescatter_block(ConcreteTemplate):
    key = globals()["ulonglong_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_min_reducescatter_block, types.Function(_typing_ulonglong_min_reducescatter_block))


@register
class _typing_int8_min_reducescatter_block(ConcreteTemplate):
    key = globals()["int8_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_min_reducescatter_block, types.Function(_typing_int8_min_reducescatter_block))


@register
class _typing_int16_min_reducescatter_block(ConcreteTemplate):
    key = globals()["int16_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_min_reducescatter_block, types.Function(_typing_int16_min_reducescatter_block))


@register
class _typing_int32_min_reducescatter_block(ConcreteTemplate):
    key = globals()["int32_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_min_reducescatter_block, types.Function(_typing_int32_min_reducescatter_block))


@register
class _typing_int64_min_reducescatter_block(ConcreteTemplate):
    key = globals()["int64_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_min_reducescatter_block, types.Function(_typing_int64_min_reducescatter_block))


@register
class _typing_uint8_min_reducescatter_block(ConcreteTemplate):
    key = globals()["uint8_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_min_reducescatter_block, types.Function(_typing_uint8_min_reducescatter_block))


@register
class _typing_uint16_min_reducescatter_block(ConcreteTemplate):
    key = globals()["uint16_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_min_reducescatter_block, types.Function(_typing_uint16_min_reducescatter_block))


@register
class _typing_uint32_min_reducescatter_block(ConcreteTemplate):
    key = globals()["uint32_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_min_reducescatter_block, types.Function(_typing_uint32_min_reducescatter_block))


@register
class _typing_uint64_min_reducescatter_block(ConcreteTemplate):
    key = globals()["uint64_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_min_reducescatter_block, types.Function(_typing_uint64_min_reducescatter_block))


@register
class _typing_size_min_reducescatter_block(ConcreteTemplate):
    key = globals()["size_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_min_reducescatter_block, types.Function(_typing_size_min_reducescatter_block))


@register
class _typing_char_min_reducescatter_block(ConcreteTemplate):
    key = globals()["char_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_min_reducescatter_block, types.Function(_typing_char_min_reducescatter_block))


@register
class _typing_schar_min_reducescatter_block(ConcreteTemplate):
    key = globals()["schar_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_min_reducescatter_block, types.Function(_typing_schar_min_reducescatter_block))


@register
class _typing_short_min_reducescatter_block(ConcreteTemplate):
    key = globals()["short_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_min_reducescatter_block, types.Function(_typing_short_min_reducescatter_block))


@register
class _typing_int_min_reducescatter_block(ConcreteTemplate):
    key = globals()["int_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_min_reducescatter_block, types.Function(_typing_int_min_reducescatter_block))


@register
class _typing_long_min_reducescatter_block(ConcreteTemplate):
    key = globals()["long_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_min_reducescatter_block, types.Function(_typing_long_min_reducescatter_block))


@register
class _typing_longlong_min_reducescatter_block(ConcreteTemplate):
    key = globals()["longlong_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_min_reducescatter_block, types.Function(_typing_longlong_min_reducescatter_block))


@register
class _typing_bfloat16_min_reducescatter_block(ConcreteTemplate):
    key = globals()["bfloat16_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_min_reducescatter_block, types.Function(_typing_bfloat16_min_reducescatter_block))


@register
class _typing_half_min_reducescatter_block(ConcreteTemplate):
    key = globals()["half_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_min_reducescatter_block, types.Function(_typing_half_min_reducescatter_block))


@register
class _typing_float_min_reducescatter_block(ConcreteTemplate):
    key = globals()["float_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_min_reducescatter_block, types.Function(_typing_float_min_reducescatter_block))


@register
class _typing_double_min_reducescatter_block(ConcreteTemplate):
    key = globals()["double_min_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_min_reducescatter_block, types.Function(_typing_double_min_reducescatter_block))


@register
class _typing_uchar_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["uchar_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_sum_reducescatter_block, types.Function(_typing_uchar_sum_reducescatter_block))


@register
class _typing_ushort_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["ushort_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_sum_reducescatter_block, types.Function(_typing_ushort_sum_reducescatter_block))


@register
class _typing_uint_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["uint_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_sum_reducescatter_block, types.Function(_typing_uint_sum_reducescatter_block))


@register
class _typing_ulong_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["ulong_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_sum_reducescatter_block, types.Function(_typing_ulong_sum_reducescatter_block))


@register
class _typing_ulonglong_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["ulonglong_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_sum_reducescatter_block, types.Function(_typing_ulonglong_sum_reducescatter_block))


@register
class _typing_int8_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["int8_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_sum_reducescatter_block, types.Function(_typing_int8_sum_reducescatter_block))


@register
class _typing_int16_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["int16_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_sum_reducescatter_block, types.Function(_typing_int16_sum_reducescatter_block))


@register
class _typing_int32_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["int32_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_sum_reducescatter_block, types.Function(_typing_int32_sum_reducescatter_block))


@register
class _typing_int64_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["int64_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_sum_reducescatter_block, types.Function(_typing_int64_sum_reducescatter_block))


@register
class _typing_uint8_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["uint8_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_sum_reducescatter_block, types.Function(_typing_uint8_sum_reducescatter_block))


@register
class _typing_uint16_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["uint16_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_sum_reducescatter_block, types.Function(_typing_uint16_sum_reducescatter_block))


@register
class _typing_uint32_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["uint32_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_sum_reducescatter_block, types.Function(_typing_uint32_sum_reducescatter_block))


@register
class _typing_uint64_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["uint64_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_sum_reducescatter_block, types.Function(_typing_uint64_sum_reducescatter_block))


@register
class _typing_size_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["size_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_sum_reducescatter_block, types.Function(_typing_size_sum_reducescatter_block))


@register
class _typing_char_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["char_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_sum_reducescatter_block, types.Function(_typing_char_sum_reducescatter_block))


@register
class _typing_schar_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["schar_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_sum_reducescatter_block, types.Function(_typing_schar_sum_reducescatter_block))


@register
class _typing_short_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["short_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_sum_reducescatter_block, types.Function(_typing_short_sum_reducescatter_block))


@register
class _typing_int_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["int_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_sum_reducescatter_block, types.Function(_typing_int_sum_reducescatter_block))


@register
class _typing_long_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["long_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_sum_reducescatter_block, types.Function(_typing_long_sum_reducescatter_block))


@register
class _typing_longlong_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["longlong_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_sum_reducescatter_block, types.Function(_typing_longlong_sum_reducescatter_block))


@register
class _typing_bfloat16_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["bfloat16_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_sum_reducescatter_block, types.Function(_typing_bfloat16_sum_reducescatter_block))


@register
class _typing_half_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["half_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_sum_reducescatter_block, types.Function(_typing_half_sum_reducescatter_block))


@register
class _typing_float_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["float_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_sum_reducescatter_block, types.Function(_typing_float_sum_reducescatter_block))


@register
class _typing_double_sum_reducescatter_block(ConcreteTemplate):
    key = globals()["double_sum_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_sum_reducescatter_block, types.Function(_typing_double_sum_reducescatter_block))


@register
class _typing_uchar_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["uchar_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uchar_prod_reducescatter_block, types.Function(_typing_uchar_prod_reducescatter_block))


@register
class _typing_ushort_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["ushort_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(ushort_prod_reducescatter_block, types.Function(_typing_ushort_prod_reducescatter_block))


@register
class _typing_uint_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["uint_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint_prod_reducescatter_block, types.Function(_typing_uint_prod_reducescatter_block))


@register
class _typing_ulong_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["ulong_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulong_prod_reducescatter_block, types.Function(_typing_ulong_prod_reducescatter_block))


@register
class _typing_ulonglong_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["ulonglong_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(ulonglong_prod_reducescatter_block, types.Function(_typing_ulonglong_prod_reducescatter_block))


@register
class _typing_int8_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["int8_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(int8_prod_reducescatter_block, types.Function(_typing_int8_prod_reducescatter_block))


@register
class _typing_int16_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["int16_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(int16_prod_reducescatter_block, types.Function(_typing_int16_prod_reducescatter_block))


@register
class _typing_int32_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["int32_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int32_prod_reducescatter_block, types.Function(_typing_int32_prod_reducescatter_block))


@register
class _typing_int64_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["int64_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(int64_prod_reducescatter_block, types.Function(_typing_int64_prod_reducescatter_block))


@register
class _typing_uint8_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["uint8_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint8), CPointer(uint8), uint64)]

register_global(uint8_prod_reducescatter_block, types.Function(_typing_uint8_prod_reducescatter_block))


@register
class _typing_uint16_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["uint16_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint16), CPointer(uint16), uint64)]

register_global(uint16_prod_reducescatter_block, types.Function(_typing_uint16_prod_reducescatter_block))


@register
class _typing_uint32_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["uint32_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint32), CPointer(uint32), uint64)]

register_global(uint32_prod_reducescatter_block, types.Function(_typing_uint32_prod_reducescatter_block))


@register
class _typing_uint64_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["uint64_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(uint64_prod_reducescatter_block, types.Function(_typing_uint64_prod_reducescatter_block))


@register
class _typing_size_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["size_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(uint64), CPointer(uint64), uint64)]

register_global(size_prod_reducescatter_block, types.Function(_typing_size_prod_reducescatter_block))


@register
class _typing_char_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["char_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(char_prod_reducescatter_block, types.Function(_typing_char_prod_reducescatter_block))


@register
class _typing_schar_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["schar_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int8), CPointer(int8), uint64)]

register_global(schar_prod_reducescatter_block, types.Function(_typing_schar_prod_reducescatter_block))


@register
class _typing_short_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["short_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int16), CPointer(int16), uint64)]

register_global(short_prod_reducescatter_block, types.Function(_typing_short_prod_reducescatter_block))


@register
class _typing_int_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["int_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int32), CPointer(int32), uint64)]

register_global(int_prod_reducescatter_block, types.Function(_typing_int_prod_reducescatter_block))


@register
class _typing_long_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["long_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(long_prod_reducescatter_block, types.Function(_typing_long_prod_reducescatter_block))


@register
class _typing_longlong_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["longlong_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(int64), CPointer(int64), uint64)]

register_global(longlong_prod_reducescatter_block, types.Function(_typing_longlong_prod_reducescatter_block))


@register
class _typing_bfloat16_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["bfloat16_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(bfloat16), CPointer(bfloat16), uint64)]

register_global(bfloat16_prod_reducescatter_block, types.Function(_typing_bfloat16_prod_reducescatter_block))


@register
class _typing_half_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["half_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(float16), CPointer(float16), uint64)]

register_global(half_prod_reducescatter_block, types.Function(_typing_half_prod_reducescatter_block))


@register
class _typing_float_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["float_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(float32), CPointer(float32), uint64)]

register_global(float_prod_reducescatter_block, types.Function(_typing_float_prod_reducescatter_block))


@register
class _typing_double_prod_reducescatter_block(ConcreteTemplate):
    key = globals()["double_prod_reducescatter_block"]
    cases = [signature(int32, int32, CPointer(float64), CPointer(float64), uint64)]

register_global(double_prod_reducescatter_block, types.Function(_typing_double_prod_reducescatter_block))


@register
class _typing_double2_maxloc_reduce_block(ConcreteTemplate):
    key = globals()["double2_maxloc_reduce_block"]
    cases = [signature(int32, int32, CPointer(float64x2), CPointer(float64x2), uint64)]

register_global(double2_maxloc_reduce_block, types.Function(_typing_double2_maxloc_reduce_block))


# Aliases:


# Symbols:


_NBTYPE_SYMBOLS = []


_RECORD_SYMBOLS = []


_FUNCTION_SYMBOLS = ["team_my_pe","team_n_pes","team_translate_pe","my_pe","n_pes","info_get_name","info_get_version","bfloat16_p","half_p","float_p","double_p","char_p","short_p","schar_p","int_p","long_p","longlong_p","uchar_p","ushort_p","uint_p","ulong_p","ulonglong_p","int8_p","int16_p","int32_p","int64_p","uint8_p","uint16_p","uint32_p","uint64_p","size_p","ptrdiff_p","bfloat16_g","half_g","float_g","double_g","char_g","short_g","schar_g","int_g","long_g","longlong_g","uchar_g","ushort_g","uint_g","ulong_g","ulonglong_g","int8_g","int16_g","int32_g","int64_g","uint8_g","uint16_g","uint32_g","uint64_g","size_g","ptrdiff_g","bfloat16_put","half_put","float_put","double_put","char_put","short_put","schar_put","int_put","long_put","longlong_put","uchar_put","ushort_put","uint_put","ulong_put","ulonglong_put","int8_put","int16_put","int32_put","int64_put","uint8_put","uint16_put","uint32_put","uint64_put","size_put","ptrdiff_put","bfloat16_put_signal","half_put_signal","float_put_signal","double_put_signal","char_put_signal","short_put_signal","schar_put_signal","int_put_signal","long_put_signal","longlong_put_signal","uchar_put_signal","ushort_put_signal","uint_put_signal","ulong_put_signal","ulonglong_put_signal","int8_put_signal","int16_put_signal","int32_put_signal","int64_put_signal","uint8_put_signal","uint16_put_signal","uint32_put_signal","uint64_put_signal","size_put_signal","ptrdiff_put_signal","bfloat16_get","half_get","float_get","double_get","char_get","short_get","schar_get","int_get","long_get","longlong_get","uchar_get","ushort_get","uint_get","ulong_get","ulonglong_get","int8_get","int16_get","int32_get","int64_get","uint8_get","uint16_get","uint32_get","uint64_get","size_get","ptrdiff_get","put8","put16","put32","put64","put128","putmem_signal","put8_signal","put16_signal","put32_signal","put64_signal","put128_signal","get8","get16","get32","get64","get128","putmem","getmem","bfloat16_put_nbi","half_put_nbi","float_put_nbi","double_put_nbi","char_put_nbi","short_put_nbi","schar_put_nbi","int_put_nbi","long_put_nbi","longlong_put_nbi","uchar_put_nbi","ushort_put_nbi","uint_put_nbi","ulong_put_nbi","ulonglong_put_nbi","int8_put_nbi","int16_put_nbi","int32_put_nbi","int64_put_nbi","uint8_put_nbi","uint16_put_nbi","uint32_put_nbi","uint64_put_nbi","size_put_nbi","ptrdiff_put_nbi","bfloat16_put_signal_nbi","half_put_signal_nbi","float_put_signal_nbi","double_put_signal_nbi","char_put_signal_nbi","short_put_signal_nbi","schar_put_signal_nbi","int_put_signal_nbi","long_put_signal_nbi","longlong_put_signal_nbi","uchar_put_signal_nbi","ushort_put_signal_nbi","uint_put_signal_nbi","ulong_put_signal_nbi","ulonglong_put_signal_nbi","int8_put_signal_nbi","int16_put_signal_nbi","int32_put_signal_nbi","int64_put_signal_nbi","uint8_put_signal_nbi","uint16_put_signal_nbi","uint32_put_signal_nbi","uint64_put_signal_nbi","size_put_signal_nbi","ptrdiff_put_signal_nbi","bfloat16_get_nbi","half_get_nbi","float_get_nbi","double_get_nbi","char_get_nbi","short_get_nbi","schar_get_nbi","int_get_nbi","long_get_nbi","longlong_get_nbi","uchar_get_nbi","ushort_get_nbi","uint_get_nbi","ulong_get_nbi","ulonglong_get_nbi","int8_get_nbi","int16_get_nbi","int32_get_nbi","int64_get_nbi","uint8_get_nbi","uint16_get_nbi","uint32_get_nbi","uint64_get_nbi","size_get_nbi","ptrdiff_get_nbi","put8_nbi","put16_nbi","put32_nbi","put64_nbi","put128_nbi","get8_nbi","get16_nbi","get32_nbi","get64_nbi","get128_nbi","putmem_nbi","putmem_signal_nbi","put8_signal_nbi","put16_signal_nbi","put32_signal_nbi","put64_signal_nbi","put128_signal_nbi","getmem_nbi","bfloat16_iput","half_iput","float_iput","double_iput","char_iput","short_iput","schar_iput","int_iput","long_iput","longlong_iput","uchar_iput","ushort_iput","uint_iput","ulong_iput","ulonglong_iput","int8_iput","int16_iput","int32_iput","int64_iput","uint8_iput","uint16_iput","uint32_iput","uint64_iput","size_iput","ptrdiff_iput","iput8","iput16","iput32","iput64","iput128","bfloat16_iget","half_iget","float_iget","double_iget","char_iget","short_iget","schar_iget","int_iget","long_iget","longlong_iget","uchar_iget","ushort_iget","uint_iget","ulong_iget","ulonglong_iget","int8_iget","int16_iget","int32_iget","int64_iget","uint8_iget","uint16_iget","uint32_iget","uint64_iget","size_iget","ptrdiff_iget","iget8","iget16","iget32","iget64","iget128","short_test","int_test","long_test","longlong_test","ushort_test","uint_test","ulong_test","ulonglong_test","int32_test","int64_test","uint32_test","uint64_test","size_test","ptrdiff_test","short_test_all","int_test_all","long_test_all","longlong_test_all","ushort_test_all","uint_test_all","ulong_test_all","ulonglong_test_all","int32_test_all","int64_test_all","uint32_test_all","uint64_test_all","size_test_all","ptrdiff_test_all","short_test_any","int_test_any","long_test_any","longlong_test_any","ushort_test_any","uint_test_any","ulong_test_any","ulonglong_test_any","int32_test_any","int64_test_any","uint32_test_any","uint64_test_any","size_test_any","ptrdiff_test_any","short_test_some","int_test_some","long_test_some","longlong_test_some","ushort_test_some","uint_test_some","ulong_test_some","ulonglong_test_some","int32_test_some","int64_test_some","uint32_test_some","uint64_test_some","size_test_some","ptrdiff_test_some","short_test_all_vector","int_test_all_vector","long_test_all_vector","longlong_test_all_vector","ushort_test_all_vector","uint_test_all_vector","ulong_test_all_vector","ulonglong_test_all_vector","int32_test_all_vector","int64_test_all_vector","uint32_test_all_vector","uint64_test_all_vector","size_test_all_vector","ptrdiff_test_all_vector","short_test_any_vector","int_test_any_vector","long_test_any_vector","longlong_test_any_vector","ushort_test_any_vector","uint_test_any_vector","ulong_test_any_vector","ulonglong_test_any_vector","int32_test_any_vector","int64_test_any_vector","uint32_test_any_vector","uint64_test_any_vector","size_test_any_vector","ptrdiff_test_any_vector","short_test_some_vector","int_test_some_vector","long_test_some_vector","longlong_test_some_vector","ushort_test_some_vector","uint_test_some_vector","ulong_test_some_vector","ulonglong_test_some_vector","int32_test_some_vector","int64_test_some_vector","uint32_test_some_vector","uint64_test_some_vector","size_test_some_vector","ptrdiff_test_some_vector","short_wait_until","int_wait_until","long_wait_until","longlong_wait_until","ushort_wait_until","uint_wait_until","ulong_wait_until","ulonglong_wait_until","int32_wait_until","int64_wait_until","uint32_wait_until","uint64_wait_until","size_wait_until","ptrdiff_wait_until","signal_fetch","signal_wait_until","short_wait_until_all","int_wait_until_all","long_wait_until_all","longlong_wait_until_all","ushort_wait_until_all","uint_wait_until_all","ulong_wait_until_all","ulonglong_wait_until_all","int32_wait_until_all","int64_wait_until_all","uint32_wait_until_all","uint64_wait_until_all","size_wait_until_all","ptrdiff_wait_until_all","short_wait_until_any","int_wait_until_any","long_wait_until_any","longlong_wait_until_any","ushort_wait_until_any","uint_wait_until_any","ulong_wait_until_any","ulonglong_wait_until_any","int32_wait_until_any","int64_wait_until_any","uint32_wait_until_any","uint64_wait_until_any","size_wait_until_any","ptrdiff_wait_until_any","short_wait_until_some","int_wait_until_some","long_wait_until_some","longlong_wait_until_some","ushort_wait_until_some","uint_wait_until_some","ulong_wait_until_some","ulonglong_wait_until_some","int32_wait_until_some","int64_wait_until_some","uint32_wait_until_some","uint64_wait_until_some","size_wait_until_some","ptrdiff_wait_until_some","short_wait_until_all_vector","int_wait_until_all_vector","long_wait_until_all_vector","longlong_wait_until_all_vector","ushort_wait_until_all_vector","uint_wait_until_all_vector","ulong_wait_until_all_vector","ulonglong_wait_until_all_vector","int32_wait_until_all_vector","int64_wait_until_all_vector","uint32_wait_until_all_vector","uint64_wait_until_all_vector","size_wait_until_all_vector","ptrdiff_wait_until_all_vector","short_wait_until_any_vector","int_wait_until_any_vector","long_wait_until_any_vector","longlong_wait_until_any_vector","ushort_wait_until_any_vector","uint_wait_until_any_vector","ulong_wait_until_any_vector","ulonglong_wait_until_any_vector","int32_wait_until_any_vector","int64_wait_until_any_vector","uint32_wait_until_any_vector","uint64_wait_until_any_vector","size_wait_until_any_vector","ptrdiff_wait_until_any_vector","short_wait_until_some_vector","int_wait_until_some_vector","long_wait_until_some_vector","longlong_wait_until_some_vector","ushort_wait_until_some_vector","uint_wait_until_some_vector","ulong_wait_until_some_vector","ulonglong_wait_until_some_vector","int32_wait_until_some_vector","int64_wait_until_some_vector","uint32_wait_until_some_vector","uint64_wait_until_some_vector","size_wait_until_some_vector","ptrdiff_wait_until_some_vector","quiet","fence","int_atomic_fetch_add","long_atomic_fetch_add","uint_atomic_fetch_add","ulong_atomic_fetch_add","ulonglong_atomic_fetch_add","int32_atomic_fetch_add","uint32_atomic_fetch_add","uint64_atomic_fetch_add","size_atomic_fetch_add","int_atomic_add","long_atomic_add","uint_atomic_add","ulong_atomic_add","ulonglong_atomic_add","int32_atomic_add","uint32_atomic_add","uint64_atomic_add","size_atomic_add","int_atomic_fetch_inc","long_atomic_fetch_inc","uint_atomic_fetch_inc","ulong_atomic_fetch_inc","ulonglong_atomic_fetch_inc","int32_atomic_fetch_inc","uint32_atomic_fetch_inc","uint64_atomic_fetch_inc","size_atomic_fetch_inc","int_atomic_inc","long_atomic_inc","uint_atomic_inc","ulong_atomic_inc","ulonglong_atomic_inc","int32_atomic_inc","uint32_atomic_inc","uint64_atomic_inc","size_atomic_inc","int_atomic_compare_swap","long_atomic_compare_swap","longlong_atomic_compare_swap","uint_atomic_compare_swap","ulong_atomic_compare_swap","ulonglong_atomic_compare_swap","int32_atomic_compare_swap","int64_atomic_compare_swap","uint32_atomic_compare_swap","uint64_atomic_compare_swap","size_atomic_compare_swap","ptrdiff_atomic_compare_swap","uint_atomic_fetch_and","ulong_atomic_fetch_and","ulonglong_atomic_fetch_and","int32_atomic_fetch_and","int64_atomic_fetch_and","uint32_atomic_fetch_and","uint64_atomic_fetch_and","uint_atomic_and","ulong_atomic_and","ulonglong_atomic_and","int32_atomic_and","int64_atomic_and","uint32_atomic_and","uint64_atomic_and","uint_atomic_fetch_or","ulong_atomic_fetch_or","ulonglong_atomic_fetch_or","int32_atomic_fetch_or","int64_atomic_fetch_or","uint32_atomic_fetch_or","uint64_atomic_fetch_or","uint_atomic_or","ulong_atomic_or","ulonglong_atomic_or","int32_atomic_or","int64_atomic_or","uint32_atomic_or","uint64_atomic_or","uint_atomic_fetch_xor","ulong_atomic_fetch_xor","ulonglong_atomic_fetch_xor","int32_atomic_fetch_xor","int64_atomic_fetch_xor","uint32_atomic_fetch_xor","uint64_atomic_fetch_xor","uint_atomic_xor","ulong_atomic_xor","ulonglong_atomic_xor","int32_atomic_xor","int64_atomic_xor","uint32_atomic_xor","uint64_atomic_xor","int_atomic_swap","long_atomic_swap","longlong_atomic_swap","uint_atomic_swap","ulong_atomic_swap","ulonglong_atomic_swap","int32_atomic_swap","int64_atomic_swap","uint32_atomic_swap","uint64_atomic_swap","float_atomic_swap","double_atomic_swap","size_atomic_swap","ptrdiff_atomic_swap","int_atomic_fetch","long_atomic_fetch","longlong_atomic_fetch","uint_atomic_fetch","ulong_atomic_fetch","ulonglong_atomic_fetch","int32_atomic_fetch","int64_atomic_fetch","uint32_atomic_fetch","uint64_atomic_fetch","float_atomic_fetch","double_atomic_fetch","size_atomic_fetch","ptrdiff_atomic_fetch","int_atomic_set","long_atomic_set","longlong_atomic_set","uint_atomic_set","ulong_atomic_set","ulonglong_atomic_set","int32_atomic_set","int64_atomic_set","uint32_atomic_set","uint64_atomic_set","float_atomic_set","double_atomic_set","size_atomic_set","ptrdiff_atomic_set","alltoallmem","bfloat16_alltoall","half_alltoall","float_alltoall","double_alltoall","char_alltoall","short_alltoall","schar_alltoall","int_alltoall","long_alltoall","longlong_alltoall","uchar_alltoall","ushort_alltoall","uint_alltoall","ulong_alltoall","ulonglong_alltoall","int8_alltoall","int16_alltoall","int32_alltoall","int64_alltoall","uint8_alltoall","uint16_alltoall","uint32_alltoall","uint64_alltoall","size_alltoall","ptrdiff_alltoall","barrier","barrier_all","team_sync","sync_all","broadcastmem","bfloat16_broadcast","half_broadcast","float_broadcast","double_broadcast","char_broadcast","short_broadcast","schar_broadcast","int_broadcast","long_broadcast","longlong_broadcast","uchar_broadcast","ushort_broadcast","uint_broadcast","ulong_broadcast","ulonglong_broadcast","int8_broadcast","int16_broadcast","int32_broadcast","int64_broadcast","uint8_broadcast","uint16_broadcast","uint32_broadcast","uint64_broadcast","size_broadcast","ptrdiff_broadcast","fcollectmem","bfloat16_fcollect","half_fcollect","float_fcollect","double_fcollect","char_fcollect","short_fcollect","schar_fcollect","int_fcollect","long_fcollect","longlong_fcollect","uchar_fcollect","ushort_fcollect","uint_fcollect","ulong_fcollect","ulonglong_fcollect","int8_fcollect","int16_fcollect","int32_fcollect","int64_fcollect","uint8_fcollect","uint16_fcollect","uint32_fcollect","uint64_fcollect","size_fcollect","ptrdiff_fcollect","uchar_and_reduce","ushort_and_reduce","uint_and_reduce","ulong_and_reduce","ulonglong_and_reduce","int8_and_reduce","int16_and_reduce","int32_and_reduce","int64_and_reduce","uint8_and_reduce","uint16_and_reduce","uint32_and_reduce","uint64_and_reduce","size_and_reduce","uchar_or_reduce","ushort_or_reduce","uint_or_reduce","ulong_or_reduce","ulonglong_or_reduce","int8_or_reduce","int16_or_reduce","int32_or_reduce","int64_or_reduce","uint8_or_reduce","uint16_or_reduce","uint32_or_reduce","uint64_or_reduce","size_or_reduce","uchar_xor_reduce","ushort_xor_reduce","uint_xor_reduce","ulong_xor_reduce","ulonglong_xor_reduce","int8_xor_reduce","int16_xor_reduce","int32_xor_reduce","int64_xor_reduce","uint8_xor_reduce","uint16_xor_reduce","uint32_xor_reduce","uint64_xor_reduce","size_xor_reduce","uchar_max_reduce","ushort_max_reduce","uint_max_reduce","ulong_max_reduce","ulonglong_max_reduce","int8_max_reduce","int16_max_reduce","int32_max_reduce","int64_max_reduce","uint8_max_reduce","uint16_max_reduce","uint32_max_reduce","uint64_max_reduce","size_max_reduce","char_max_reduce","schar_max_reduce","short_max_reduce","int_max_reduce","long_max_reduce","longlong_max_reduce","bfloat16_max_reduce","half_max_reduce","float_max_reduce","double_max_reduce","uchar_min_reduce","ushort_min_reduce","uint_min_reduce","ulong_min_reduce","ulonglong_min_reduce","int8_min_reduce","int16_min_reduce","int32_min_reduce","int64_min_reduce","uint8_min_reduce","uint16_min_reduce","uint32_min_reduce","uint64_min_reduce","size_min_reduce","char_min_reduce","schar_min_reduce","short_min_reduce","int_min_reduce","long_min_reduce","longlong_min_reduce","bfloat16_min_reduce","half_min_reduce","float_min_reduce","double_min_reduce","uchar_sum_reduce","ushort_sum_reduce","uint_sum_reduce","ulong_sum_reduce","ulonglong_sum_reduce","int8_sum_reduce","int16_sum_reduce","int32_sum_reduce","int64_sum_reduce","uint8_sum_reduce","uint16_sum_reduce","uint32_sum_reduce","uint64_sum_reduce","size_sum_reduce","char_sum_reduce","schar_sum_reduce","short_sum_reduce","int_sum_reduce","long_sum_reduce","longlong_sum_reduce","bfloat16_sum_reduce","half_sum_reduce","float_sum_reduce","double_sum_reduce","uchar_prod_reduce","ushort_prod_reduce","uint_prod_reduce","ulong_prod_reduce","ulonglong_prod_reduce","int8_prod_reduce","int16_prod_reduce","int32_prod_reduce","int64_prod_reduce","uint8_prod_reduce","uint16_prod_reduce","uint32_prod_reduce","uint64_prod_reduce","size_prod_reduce","char_prod_reduce","schar_prod_reduce","short_prod_reduce","int_prod_reduce","long_prod_reduce","longlong_prod_reduce","bfloat16_prod_reduce","half_prod_reduce","float_prod_reduce","double_prod_reduce","uchar_and_reducescatter","ushort_and_reducescatter","uint_and_reducescatter","ulong_and_reducescatter","ulonglong_and_reducescatter","int8_and_reducescatter","int16_and_reducescatter","int32_and_reducescatter","int64_and_reducescatter","uint8_and_reducescatter","uint16_and_reducescatter","uint32_and_reducescatter","uint64_and_reducescatter","size_and_reducescatter","uchar_or_reducescatter","ushort_or_reducescatter","uint_or_reducescatter","ulong_or_reducescatter","ulonglong_or_reducescatter","int8_or_reducescatter","int16_or_reducescatter","int32_or_reducescatter","int64_or_reducescatter","uint8_or_reducescatter","uint16_or_reducescatter","uint32_or_reducescatter","uint64_or_reducescatter","size_or_reducescatter","uchar_xor_reducescatter","ushort_xor_reducescatter","uint_xor_reducescatter","ulong_xor_reducescatter","ulonglong_xor_reducescatter","int8_xor_reducescatter","int16_xor_reducescatter","int32_xor_reducescatter","int64_xor_reducescatter","uint8_xor_reducescatter","uint16_xor_reducescatter","uint32_xor_reducescatter","uint64_xor_reducescatter","size_xor_reducescatter","uchar_max_reducescatter","ushort_max_reducescatter","uint_max_reducescatter","ulong_max_reducescatter","ulonglong_max_reducescatter","int8_max_reducescatter","int16_max_reducescatter","int32_max_reducescatter","int64_max_reducescatter","uint8_max_reducescatter","uint16_max_reducescatter","uint32_max_reducescatter","uint64_max_reducescatter","size_max_reducescatter","char_max_reducescatter","schar_max_reducescatter","short_max_reducescatter","int_max_reducescatter","long_max_reducescatter","longlong_max_reducescatter","bfloat16_max_reducescatter","half_max_reducescatter","float_max_reducescatter","double_max_reducescatter","uchar_min_reducescatter","ushort_min_reducescatter","uint_min_reducescatter","ulong_min_reducescatter","ulonglong_min_reducescatter","int8_min_reducescatter","int16_min_reducescatter","int32_min_reducescatter","int64_min_reducescatter","uint8_min_reducescatter","uint16_min_reducescatter","uint32_min_reducescatter","uint64_min_reducescatter","size_min_reducescatter","char_min_reducescatter","schar_min_reducescatter","short_min_reducescatter","int_min_reducescatter","long_min_reducescatter","longlong_min_reducescatter","bfloat16_min_reducescatter","half_min_reducescatter","float_min_reducescatter","double_min_reducescatter","uchar_sum_reducescatter","ushort_sum_reducescatter","uint_sum_reducescatter","ulong_sum_reducescatter","ulonglong_sum_reducescatter","int8_sum_reducescatter","int16_sum_reducescatter","int32_sum_reducescatter","int64_sum_reducescatter","uint8_sum_reducescatter","uint16_sum_reducescatter","uint32_sum_reducescatter","uint64_sum_reducescatter","size_sum_reducescatter","char_sum_reducescatter","schar_sum_reducescatter","short_sum_reducescatter","int_sum_reducescatter","long_sum_reducescatter","longlong_sum_reducescatter","bfloat16_sum_reducescatter","half_sum_reducescatter","float_sum_reducescatter","double_sum_reducescatter","uchar_prod_reducescatter","ushort_prod_reducescatter","uint_prod_reducescatter","ulong_prod_reducescatter","ulonglong_prod_reducescatter","int8_prod_reducescatter","int16_prod_reducescatter","int32_prod_reducescatter","int64_prod_reducescatter","uint8_prod_reducescatter","uint16_prod_reducescatter","uint32_prod_reducescatter","uint64_prod_reducescatter","size_prod_reducescatter","char_prod_reducescatter","schar_prod_reducescatter","short_prod_reducescatter","int_prod_reducescatter","long_prod_reducescatter","longlong_prod_reducescatter","bfloat16_prod_reducescatter","half_prod_reducescatter","float_prod_reducescatter","double_prod_reducescatter","vendor_get_version_info","signal_op","mc_ptr","bfloat16_put_warp","bfloat16_put_block","half_put_warp","half_put_block","float_put_warp","float_put_block","double_put_warp","double_put_block","char_put_warp","char_put_block","short_put_warp","short_put_block","schar_put_warp","schar_put_block","int_put_warp","int_put_block","long_put_warp","long_put_block","longlong_put_warp","longlong_put_block","uchar_put_warp","uchar_put_block","ushort_put_warp","ushort_put_block","uint_put_warp","uint_put_block","ulong_put_warp","ulong_put_block","ulonglong_put_warp","ulonglong_put_block","int8_put_warp","int8_put_block","int16_put_warp","int16_put_block","int32_put_warp","int32_put_block","int64_put_warp","int64_put_block","uint8_put_warp","uint8_put_block","uint16_put_warp","uint16_put_block","uint32_put_warp","uint32_put_block","uint64_put_warp","uint64_put_block","size_put_warp","size_put_block","ptrdiff_put_warp","ptrdiff_put_block","nvshmemi_bfloat16_put_signal_warp","nvshmemi_half_put_signal_warp","nvshmemi_float_put_signal_warp","nvshmemi_double_put_signal_warp","nvshmemi_char_put_signal_warp","nvshmemi_short_put_signal_warp","nvshmemi_schar_put_signal_warp","nvshmemi_int_put_signal_warp","nvshmemi_long_put_signal_warp","nvshmemi_longlong_put_signal_warp","nvshmemi_uchar_put_signal_warp","nvshmemi_ushort_put_signal_warp","nvshmemi_uint_put_signal_warp","nvshmemi_ulong_put_signal_warp","nvshmemi_ulonglong_put_signal_warp","nvshmemi_int8_put_signal_warp","nvshmemi_int16_put_signal_warp","nvshmemi_int32_put_signal_warp","nvshmemi_int64_put_signal_warp","nvshmemi_uint8_put_signal_warp","nvshmemi_uint16_put_signal_warp","nvshmemi_uint32_put_signal_warp","nvshmemi_uint64_put_signal_warp","nvshmemi_size_put_signal_warp","nvshmemi_ptrdiff_put_signal_warp","nvshmemi_bfloat16_put_signal_block","nvshmemi_half_put_signal_block","nvshmemi_float_put_signal_block","nvshmemi_double_put_signal_block","nvshmemi_char_put_signal_block","nvshmemi_short_put_signal_block","nvshmemi_schar_put_signal_block","nvshmemi_int_put_signal_block","nvshmemi_long_put_signal_block","nvshmemi_longlong_put_signal_block","nvshmemi_uchar_put_signal_block","nvshmemi_ushort_put_signal_block","nvshmemi_uint_put_signal_block","nvshmemi_ulong_put_signal_block","nvshmemi_ulonglong_put_signal_block","nvshmemi_int8_put_signal_block","nvshmemi_int16_put_signal_block","nvshmemi_int32_put_signal_block","nvshmemi_int64_put_signal_block","nvshmemi_uint8_put_signal_block","nvshmemi_uint16_put_signal_block","nvshmemi_uint32_put_signal_block","nvshmemi_uint64_put_signal_block","nvshmemi_size_put_signal_block","nvshmemi_ptrdiff_put_signal_block","bfloat16_put_signal_warp","half_put_signal_warp","float_put_signal_warp","double_put_signal_warp","char_put_signal_warp","short_put_signal_warp","schar_put_signal_warp","int_put_signal_warp","long_put_signal_warp","longlong_put_signal_warp","uchar_put_signal_warp","ushort_put_signal_warp","uint_put_signal_warp","ulong_put_signal_warp","ulonglong_put_signal_warp","int8_put_signal_warp","int16_put_signal_warp","int32_put_signal_warp","int64_put_signal_warp","uint8_put_signal_warp","uint16_put_signal_warp","uint32_put_signal_warp","uint64_put_signal_warp","size_put_signal_warp","ptrdiff_put_signal_warp","bfloat16_put_signal_block","half_put_signal_block","float_put_signal_block","double_put_signal_block","char_put_signal_block","short_put_signal_block","schar_put_signal_block","int_put_signal_block","long_put_signal_block","longlong_put_signal_block","uchar_put_signal_block","ushort_put_signal_block","uint_put_signal_block","ulong_put_signal_block","ulonglong_put_signal_block","int8_put_signal_block","int16_put_signal_block","int32_put_signal_block","int64_put_signal_block","uint8_put_signal_block","uint16_put_signal_block","uint32_put_signal_block","uint64_put_signal_block","size_put_signal_block","ptrdiff_put_signal_block","putmem_signal_warp","putmem_signal_block","put8_signal_warp","put6_signal_warp","put32_signal_warp","put64_signal_warp","put128_signal_warp","put8_signal_block","put6_signal_block","put32_signal_block","put64_signal_block","put128_signal_block","bfloat16_put_signal_nbi_warp","half_put_signal_nbi_warp","float_put_signal_nbi_warp","double_put_signal_nbi_warp","char_put_signal_nbi_warp","short_put_signal_nbi_warp","schar_put_signal_nbi_warp","int_put_signal_nbi_warp","long_put_signal_nbi_warp","longlong_put_signal_nbi_warp","uchar_put_signal_nbi_warp","ushort_put_signal_nbi_warp","uint_put_signal_nbi_warp","ulong_put_signal_nbi_warp","ulonglong_put_signal_nbi_warp","int8_put_signal_nbi_warp","int16_put_signal_nbi_warp","int32_put_signal_nbi_warp","int64_put_signal_nbi_warp","uint8_put_signal_nbi_warp","uint16_put_signal_nbi_warp","uint32_put_signal_nbi_warp","uint64_put_signal_nbi_warp","size_put_signal_nbi_warp","ptrdiff_put_signal_nbi_warp","bfloat16_put_signal_nbi_block","half_put_signal_nbi_block","float_put_signal_nbi_block","double_put_signal_nbi_block","char_put_signal_nbi_block","short_put_signal_nbi_block","schar_put_signal_nbi_block","int_put_signal_nbi_block","long_put_signal_nbi_block","longlong_put_signal_nbi_block","uchar_put_signal_nbi_block","ushort_put_signal_nbi_block","uint_put_signal_nbi_block","ulong_put_signal_nbi_block","ulonglong_put_signal_nbi_block","int8_put_signal_nbi_block","int16_put_signal_nbi_block","int32_put_signal_nbi_block","int64_put_signal_nbi_block","uint8_put_signal_nbi_block","uint16_put_signal_nbi_block","uint32_put_signal_nbi_block","uint64_put_signal_nbi_block","size_put_signal_nbi_block","ptrdiff_put_signal_nbi_block","putmem_signal_nbi_warp","putmem_signal_nbi_block","put8_signal_nbi_warp","put6_signal_nbi_warp","put32_signal_nbi_warp","put64_signal_nbi_warp","put128_signal_nbi_warp","put8_signal_nbi_block","put6_signal_nbi_block","put32_signal_nbi_block","put64_signal_nbi_block","put128_signal_nbi_block","bfloat16_get_warp","bfloat16_get_block","half_get_warp","half_get_block","float_get_warp","float_get_block","double_get_warp","double_get_block","char_get_warp","char_get_block","short_get_warp","short_get_block","schar_get_warp","schar_get_block","int_get_warp","int_get_block","long_get_warp","long_get_block","longlong_get_warp","longlong_get_block","uchar_get_warp","uchar_get_block","ushort_get_warp","ushort_get_block","uint_get_warp","uint_get_block","ulong_get_warp","ulong_get_block","ulonglong_get_warp","ulonglong_get_block","int8_get_warp","int8_get_block","int16_get_warp","int16_get_block","int32_get_warp","int32_get_block","int64_get_warp","int64_get_block","uint8_get_warp","uint8_get_block","uint16_get_warp","uint16_get_block","uint32_get_warp","uint32_get_block","uint64_get_warp","uint64_get_block","size_get_warp","size_get_block","ptrdiff_get_warp","ptrdiff_get_block","put8_warp","put8_block","put16_warp","put16_block","put32_warp","put32_block","put64_warp","put64_block","put128_warp","put128_block","get8_warp","get8_block","get16_warp","get16_block","get32_warp","get32_block","get64_warp","get64_block","get128_warp","get128_block","putmem_warp","putmem_block","getmem_warp","getmem_block","bfloat16_put_nbi_warp","bfloat16_put_nbi_block","half_put_nbi_warp","half_put_nbi_block","float_put_nbi_warp","float_put_nbi_block","double_put_nbi_warp","double_put_nbi_block","char_put_nbi_warp","char_put_nbi_block","short_put_nbi_warp","short_put_nbi_block","schar_put_nbi_warp","schar_put_nbi_block","int_put_nbi_warp","int_put_nbi_block","long_put_nbi_warp","long_put_nbi_block","longlong_put_nbi_warp","longlong_put_nbi_block","uchar_put_nbi_warp","uchar_put_nbi_block","ushort_put_nbi_warp","ushort_put_nbi_block","uint_put_nbi_warp","uint_put_nbi_block","ulong_put_nbi_warp","ulong_put_nbi_block","ulonglong_put_nbi_warp","ulonglong_put_nbi_block","int8_put_nbi_warp","int8_put_nbi_block","int16_put_nbi_warp","int16_put_nbi_block","int32_put_nbi_warp","int32_put_nbi_block","int64_put_nbi_warp","int64_put_nbi_block","uint8_put_nbi_warp","uint8_put_nbi_block","uint16_put_nbi_warp","uint16_put_nbi_block","uint32_put_nbi_warp","uint32_put_nbi_block","uint64_put_nbi_warp","uint64_put_nbi_block","size_put_nbi_warp","size_put_nbi_block","ptrdiff_put_nbi_warp","ptrdiff_put_nbi_block","bfloat16_get_nbi_warp","bfloat16_get_nbi_block","half_get_nbi_warp","half_get_nbi_block","float_get_nbi_warp","float_get_nbi_block","double_get_nbi_warp","double_get_nbi_block","char_get_nbi_warp","char_get_nbi_block","short_get_nbi_warp","short_get_nbi_block","schar_get_nbi_warp","schar_get_nbi_block","int_get_nbi_warp","int_get_nbi_block","long_get_nbi_warp","long_get_nbi_block","longlong_get_nbi_warp","longlong_get_nbi_block","uchar_get_nbi_warp","uchar_get_nbi_block","ushort_get_nbi_warp","ushort_get_nbi_block","uint_get_nbi_warp","uint_get_nbi_block","ulong_get_nbi_warp","ulong_get_nbi_block","ulonglong_get_nbi_warp","ulonglong_get_nbi_block","int8_get_nbi_warp","int8_get_nbi_block","int16_get_nbi_warp","int16_get_nbi_block","int32_get_nbi_warp","int32_get_nbi_block","int64_get_nbi_warp","int64_get_nbi_block","uint8_get_nbi_warp","uint8_get_nbi_block","uint16_get_nbi_warp","uint16_get_nbi_block","uint32_get_nbi_warp","uint32_get_nbi_block","uint64_get_nbi_warp","uint64_get_nbi_block","size_get_nbi_warp","size_get_nbi_block","ptrdiff_get_nbi_warp","ptrdiff_get_nbi_block","put8_nbi_warp","put8_nbi_block","put16_nbi_warp","put16_nbi_block","put32_nbi_warp","put32_nbi_block","put64_nbi_warp","put64_nbi_block","put128_nbi_warp","put128_nbi_block","get8_nbi_warp","get8_nbi_block","get16_nbi_warp","get16_nbi_block","get32_nbi_warp","get32_nbi_block","get64_nbi_warp","get64_nbi_block","get128_nbi_warp","get128_nbi_block","putmem_nbi_warp","putmem_nbi_block","getmem_nbi_warp","getmem_nbi_block","bfloat16_iput_warp","bfloat16_iput_block","half_iput_warp","half_iput_block","float_iput_warp","float_iput_block","double_iput_warp","double_iput_block","char_iput_warp","char_iput_block","short_iput_warp","short_iput_block","schar_iput_warp","schar_iput_block","int_iput_warp","int_iput_block","long_iput_warp","long_iput_block","longlong_iput_warp","longlong_iput_block","uchar_iput_warp","uchar_iput_block","ushort_iput_warp","ushort_iput_block","uint_iput_warp","uint_iput_block","ulong_iput_warp","ulong_iput_block","ulonglong_iput_warp","ulonglong_iput_block","int8_iput_warp","int8_iput_block","int16_iput_warp","int16_iput_block","int32_iput_warp","int32_iput_block","int64_iput_warp","int64_iput_block","uint8_iput_warp","uint8_iput_block","uint16_iput_warp","uint16_iput_block","uint32_iput_warp","uint32_iput_block","uint64_iput_warp","uint64_iput_block","size_iput_warp","size_iput_block","ptrdiff_iput_warp","ptrdiff_iput_block","iput8_warp","iput8_block","iput16_warp","iput16_block","iput32_warp","iput32_block","iput64_warp","iput64_block","iput128_warp","iput128_block","bfloat16_iget_warp","bfloat16_iget_block","half_iget_warp","half_iget_block","float_iget_warp","float_iget_block","double_iget_warp","double_iget_block","char_iget_warp","char_iget_block","short_iget_warp","short_iget_block","schar_iget_warp","schar_iget_block","int_iget_warp","int_iget_block","long_iget_warp","long_iget_block","longlong_iget_warp","longlong_iget_block","uchar_iget_warp","uchar_iget_block","ushort_iget_warp","ushort_iget_block","uint_iget_warp","uint_iget_block","ulong_iget_warp","ulong_iget_block","ulonglong_iget_warp","ulonglong_iget_block","int8_iget_warp","int8_iget_block","int16_iget_warp","int16_iget_block","int32_iget_warp","int32_iget_block","int64_iget_warp","int64_iget_block","uint8_iget_warp","uint8_iget_block","uint16_iget_warp","uint16_iget_block","uint32_iget_warp","uint32_iget_block","uint64_iget_warp","uint64_iget_block","size_iget_warp","size_iget_block","ptrdiff_iget_warp","ptrdiff_iget_block","iget8_warp","iget8_block","iget16_warp","iget16_block","iget32_warp","iget32_block","iget64_warp","iget64_block","iget128_warp","iget128_block","qp_bfloat16_get","qp_bfloat16_get_warp","qp_bfloat16_get_block","qp_half_get","qp_half_get_warp","qp_half_get_block","qp_float_get","qp_float_get_warp","qp_float_get_block","qp_double_get","qp_double_get_warp","qp_double_get_block","qp_char_get","qp_char_get_warp","qp_char_get_block","qp_short_get","qp_short_get_warp","qp_short_get_block","qp_schar_get","qp_schar_get_warp","qp_schar_get_block","qp_int_get","qp_int_get_warp","qp_int_get_block","qp_long_get","qp_long_get_warp","qp_long_get_block","qp_longlong_get","qp_longlong_get_warp","qp_longlong_get_block","qp_uchar_get","qp_uchar_get_warp","qp_uchar_get_block","qp_ushort_get","qp_ushort_get_warp","qp_ushort_get_block","qp_uint_get","qp_uint_get_warp","qp_uint_get_block","qp_ulong_get","qp_ulong_get_warp","qp_ulong_get_block","qp_ulonglong_get","qp_ulonglong_get_warp","qp_ulonglong_get_block","qp_int8_get","qp_int8_get_warp","qp_int8_get_block","qp_int16_get","qp_int16_get_warp","qp_int16_get_block","qp_int32_get","qp_int32_get_warp","qp_int32_get_block","qp_int64_get","qp_int64_get_warp","qp_int64_get_block","qp_uint8_get","qp_uint8_get_warp","qp_uint8_get_block","qp_uint16_get","qp_uint16_get_warp","qp_uint16_get_block","qp_uint32_get","qp_uint32_get_warp","qp_uint32_get_block","qp_uint64_get","qp_uint64_get_warp","qp_uint64_get_block","qp_size_get","qp_size_get_warp","qp_size_get_block","qp_ptrdiff_get","qp_ptrdiff_get_warp","qp_ptrdiff_get_block","qp_bfloat16_get_nbi","qp_bfloat16_get_nbi_warp","qp_bfloat16_get_nbi_block","qp_half_get_nbi","qp_half_get_nbi_warp","qp_half_get_nbi_block","qp_float_get_nbi","qp_float_get_nbi_warp","qp_float_get_nbi_block","qp_double_get_nbi","qp_double_get_nbi_warp","qp_double_get_nbi_block","qp_char_get_nbi","qp_char_get_nbi_warp","qp_char_get_nbi_block","qp_short_get_nbi","qp_short_get_nbi_warp","qp_short_get_nbi_block","qp_schar_get_nbi","qp_schar_get_nbi_warp","qp_schar_get_nbi_block","qp_int_get_nbi","qp_int_get_nbi_warp","qp_int_get_nbi_block","qp_long_get_nbi","qp_long_get_nbi_warp","qp_long_get_nbi_block","qp_longlong_get_nbi","qp_longlong_get_nbi_warp","qp_longlong_get_nbi_block","qp_uchar_get_nbi","qp_uchar_get_nbi_warp","qp_uchar_get_nbi_block","qp_ushort_get_nbi","qp_ushort_get_nbi_warp","qp_ushort_get_nbi_block","qp_uint_get_nbi","qp_uint_get_nbi_warp","qp_uint_get_nbi_block","qp_ulong_get_nbi","qp_ulong_get_nbi_warp","qp_ulong_get_nbi_block","qp_ulonglong_get_nbi","qp_ulonglong_get_nbi_warp","qp_ulonglong_get_nbi_block","qp_int8_get_nbi","qp_int8_get_nbi_warp","qp_int8_get_nbi_block","qp_int16_get_nbi","qp_int16_get_nbi_warp","qp_int16_get_nbi_block","qp_int32_get_nbi","qp_int32_get_nbi_warp","qp_int32_get_nbi_block","qp_int64_get_nbi","qp_int64_get_nbi_warp","qp_int64_get_nbi_block","qp_uint8_get_nbi","qp_uint8_get_nbi_warp","qp_uint8_get_nbi_block","qp_uint16_get_nbi","qp_uint16_get_nbi_warp","qp_uint16_get_nbi_block","qp_uint32_get_nbi","qp_uint32_get_nbi_warp","qp_uint32_get_nbi_block","qp_uint64_get_nbi","qp_uint64_get_nbi_warp","qp_uint64_get_nbi_block","qp_size_get_nbi","qp_size_get_nbi_warp","qp_size_get_nbi_block","qp_ptrdiff_get_nbi","qp_ptrdiff_get_nbi_warp","qp_ptrdiff_get_nbi_block","qp_bfloat16_put","qp_bfloat16_put_warp","qp_bfloat16_put_block","qp_half_put","qp_half_put_warp","qp_half_put_block","qp_float_put","qp_float_put_warp","qp_float_put_block","qp_double_put","qp_double_put_warp","qp_double_put_block","qp_char_put","qp_char_put_warp","qp_char_put_block","qp_short_put","qp_short_put_warp","qp_short_put_block","qp_schar_put","qp_schar_put_warp","qp_schar_put_block","qp_int_put","qp_int_put_warp","qp_int_put_block","qp_long_put","qp_long_put_warp","qp_long_put_block","qp_longlong_put","qp_longlong_put_warp","qp_longlong_put_block","qp_uchar_put","qp_uchar_put_warp","qp_uchar_put_block","qp_ushort_put","qp_ushort_put_warp","qp_ushort_put_block","qp_uint_put","qp_uint_put_warp","qp_uint_put_block","qp_ulong_put","qp_ulong_put_warp","qp_ulong_put_block","qp_ulonglong_put","qp_ulonglong_put_warp","qp_ulonglong_put_block","qp_int8_put","qp_int8_put_warp","qp_int8_put_block","qp_int16_put","qp_int16_put_warp","qp_int16_put_block","qp_int32_put","qp_int32_put_warp","qp_int32_put_block","qp_int64_put","qp_int64_put_warp","qp_int64_put_block","qp_uint8_put","qp_uint8_put_warp","qp_uint8_put_block","qp_uint16_put","qp_uint16_put_warp","qp_uint16_put_block","qp_uint32_put","qp_uint32_put_warp","qp_uint32_put_block","qp_uint64_put","qp_uint64_put_warp","qp_uint64_put_block","qp_size_put","qp_size_put_warp","qp_size_put_block","qp_ptrdiff_put","qp_ptrdiff_put_warp","qp_ptrdiff_put_block","qp_bfloat16_put_nbi","qp_bfloat16_put_nbi_warp","qp_bfloat16_put_nbi_block","qp_half_put_nbi","qp_half_put_nbi_warp","qp_half_put_nbi_block","qp_float_put_nbi","qp_float_put_nbi_warp","qp_float_put_nbi_block","qp_double_put_nbi","qp_double_put_nbi_warp","qp_double_put_nbi_block","qp_char_put_nbi","qp_char_put_nbi_warp","qp_char_put_nbi_block","qp_short_put_nbi","qp_short_put_nbi_warp","qp_short_put_nbi_block","qp_schar_put_nbi","qp_schar_put_nbi_warp","qp_schar_put_nbi_block","qp_int_put_nbi","qp_int_put_nbi_warp","qp_int_put_nbi_block","qp_long_put_nbi","qp_long_put_nbi_warp","qp_long_put_nbi_block","qp_longlong_put_nbi","qp_longlong_put_nbi_warp","qp_longlong_put_nbi_block","qp_uchar_put_nbi","qp_uchar_put_nbi_warp","qp_uchar_put_nbi_block","qp_ushort_put_nbi","qp_ushort_put_nbi_warp","qp_ushort_put_nbi_block","qp_uint_put_nbi","qp_uint_put_nbi_warp","qp_uint_put_nbi_block","qp_ulong_put_nbi","qp_ulong_put_nbi_warp","qp_ulong_put_nbi_block","qp_ulonglong_put_nbi","qp_ulonglong_put_nbi_warp","qp_ulonglong_put_nbi_block","qp_int8_put_nbi","qp_int8_put_nbi_warp","qp_int8_put_nbi_block","qp_int16_put_nbi","qp_int16_put_nbi_warp","qp_int16_put_nbi_block","qp_int32_put_nbi","qp_int32_put_nbi_warp","qp_int32_put_nbi_block","qp_int64_put_nbi","qp_int64_put_nbi_warp","qp_int64_put_nbi_block","qp_uint8_put_nbi","qp_uint8_put_nbi_warp","qp_uint8_put_nbi_block","qp_uint16_put_nbi","qp_uint16_put_nbi_warp","qp_uint16_put_nbi_block","qp_uint32_put_nbi","qp_uint32_put_nbi_warp","qp_uint32_put_nbi_block","qp_uint64_put_nbi","qp_uint64_put_nbi_warp","qp_uint64_put_nbi_block","qp_size_put_nbi","qp_size_put_nbi_warp","qp_size_put_nbi_block","qp_ptrdiff_put_nbi","qp_ptrdiff_put_nbi_warp","qp_ptrdiff_put_nbi_block","qp_bfloat16_p","qp_half_p","qp_float_p","qp_double_p","qp_char_p","qp_short_p","qp_schar_p","qp_int_p","qp_long_p","qp_longlong_p","qp_uchar_p","qp_ushort_p","qp_uint_p","qp_ulong_p","qp_ulonglong_p","qp_int8_p","qp_int16_p","qp_int32_p","qp_int64_p","qp_uint8_p","qp_uint16_p","qp_uint32_p","qp_uint64_p","qp_size_p","qp_ptrdiff_p","qp_bfloat16_g","qp_half_g","qp_float_g","qp_double_g","qp_char_g","qp_short_g","qp_schar_g","qp_int_g","qp_long_g","qp_longlong_g","qp_uchar_g","qp_ushort_g","qp_uint_g","qp_ulong_g","qp_ulonglong_g","qp_int8_g","qp_int16_g","qp_int32_g","qp_int64_g","qp_uint8_g","qp_uint16_g","qp_uint32_g","qp_uint64_g","qp_size_g","qp_ptrdiff_g","qp_signal_op","qp_bfloat16_put_signal","qp_bfloat16_put_signal_warp","qp_bfloat16_put_signal_block","qp_half_put_signal","qp_half_put_signal_warp","qp_half_put_signal_block","qp_float_put_signal","qp_float_put_signal_warp","qp_float_put_signal_block","qp_double_put_signal","qp_double_put_signal_warp","qp_double_put_signal_block","qp_char_put_signal","qp_char_put_signal_warp","qp_char_put_signal_block","qp_short_put_signal","qp_short_put_signal_warp","qp_short_put_signal_block","qp_schar_put_signal","qp_schar_put_signal_warp","qp_schar_put_signal_block","qp_int_put_signal","qp_int_put_signal_warp","qp_int_put_signal_block","qp_long_put_signal","qp_long_put_signal_warp","qp_long_put_signal_block","qp_longlong_put_signal","qp_longlong_put_signal_warp","qp_longlong_put_signal_block","qp_uchar_put_signal","qp_uchar_put_signal_warp","qp_uchar_put_signal_block","qp_ushort_put_signal","qp_ushort_put_signal_warp","qp_ushort_put_signal_block","qp_uint_put_signal","qp_uint_put_signal_warp","qp_uint_put_signal_block","qp_ulong_put_signal","qp_ulong_put_signal_warp","qp_ulong_put_signal_block","qp_ulonglong_put_signal","qp_ulonglong_put_signal_warp","qp_ulonglong_put_signal_block","qp_int8_put_signal","qp_int8_put_signal_warp","qp_int8_put_signal_block","qp_int16_put_signal","qp_int16_put_signal_warp","qp_int16_put_signal_block","qp_int32_put_signal","qp_int32_put_signal_warp","qp_int32_put_signal_block","qp_int64_put_signal","qp_int64_put_signal_warp","qp_int64_put_signal_block","qp_uint8_put_signal","qp_uint8_put_signal_warp","qp_uint8_put_signal_block","qp_uint16_put_signal","qp_uint16_put_signal_warp","qp_uint16_put_signal_block","qp_uint32_put_signal","qp_uint32_put_signal_warp","qp_uint32_put_signal_block","qp_uint64_put_signal","qp_uint64_put_signal_warp","qp_uint64_put_signal_block","qp_size_put_signal","qp_size_put_signal_warp","qp_size_put_signal_block","qp_ptrdiff_put_signal","qp_ptrdiff_put_signal_warp","qp_ptrdiff_put_signal_block","qp_bfloat16_put_signal_nbi","qp_bfloat16_put_signal_nbi_warp","qp_bfloat16_put_signal_nbi_block","qp_half_put_signal_nbi","qp_half_put_signal_nbi_warp","qp_half_put_signal_nbi_block","qp_float_put_signal_nbi","qp_float_put_signal_nbi_warp","qp_float_put_signal_nbi_block","qp_double_put_signal_nbi","qp_double_put_signal_nbi_warp","qp_double_put_signal_nbi_block","qp_char_put_signal_nbi","qp_char_put_signal_nbi_warp","qp_char_put_signal_nbi_block","qp_short_put_signal_nbi","qp_short_put_signal_nbi_warp","qp_short_put_signal_nbi_block","qp_schar_put_signal_nbi","qp_schar_put_signal_nbi_warp","qp_schar_put_signal_nbi_block","qp_int_put_signal_nbi","qp_int_put_signal_nbi_warp","qp_int_put_signal_nbi_block","qp_long_put_signal_nbi","qp_long_put_signal_nbi_warp","qp_long_put_signal_nbi_block","qp_longlong_put_signal_nbi","qp_longlong_put_signal_nbi_warp","qp_longlong_put_signal_nbi_block","qp_uchar_put_signal_nbi","qp_uchar_put_signal_nbi_warp","qp_uchar_put_signal_nbi_block","qp_ushort_put_signal_nbi","qp_ushort_put_signal_nbi_warp","qp_ushort_put_signal_nbi_block","qp_uint_put_signal_nbi","qp_uint_put_signal_nbi_warp","qp_uint_put_signal_nbi_block","qp_ulong_put_signal_nbi","qp_ulong_put_signal_nbi_warp","qp_ulong_put_signal_nbi_block","qp_ulonglong_put_signal_nbi","qp_ulonglong_put_signal_nbi_warp","qp_ulonglong_put_signal_nbi_block","qp_int8_put_signal_nbi","qp_int8_put_signal_nbi_warp","qp_int8_put_signal_nbi_block","qp_int16_put_signal_nbi","qp_int16_put_signal_nbi_warp","qp_int16_put_signal_nbi_block","qp_int32_put_signal_nbi","qp_int32_put_signal_nbi_warp","qp_int32_put_signal_nbi_block","qp_int64_put_signal_nbi","qp_int64_put_signal_nbi_warp","qp_int64_put_signal_nbi_block","qp_uint8_put_signal_nbi","qp_uint8_put_signal_nbi_warp","qp_uint8_put_signal_nbi_block","qp_uint16_put_signal_nbi","qp_uint16_put_signal_nbi_warp","qp_uint16_put_signal_nbi_block","qp_uint32_put_signal_nbi","qp_uint32_put_signal_nbi_warp","qp_uint32_put_signal_nbi_block","qp_uint64_put_signal_nbi","qp_uint64_put_signal_nbi_warp","qp_uint64_put_signal_nbi_block","qp_size_put_signal_nbi","qp_size_put_signal_nbi_warp","qp_size_put_signal_nbi_block","qp_ptrdiff_put_signal_nbi","qp_ptrdiff_put_signal_nbi_warp","qp_ptrdiff_put_signal_nbi_block","qp_quiet","qp_quiet_warp","qp_quiet_block","qp_fence","qp_fence_warp","qp_fence_block","alltoallmem_warp","alltoallmem_block","bfloat16_alltoall_warp","half_alltoall_warp","float_alltoall_warp","double_alltoall_warp","char_alltoall_warp","short_alltoall_warp","schar_alltoall_warp","int_alltoall_warp","long_alltoall_warp","longlong_alltoall_warp","uchar_alltoall_warp","ushort_alltoall_warp","uint_alltoall_warp","ulong_alltoall_warp","ulonglong_alltoall_warp","int8_alltoall_warp","int16_alltoall_warp","int32_alltoall_warp","int64_alltoall_warp","uint8_alltoall_warp","uint16_alltoall_warp","uint32_alltoall_warp","uint64_alltoall_warp","size_alltoall_warp","ptrdiff_alltoall_warp","bfloat16_alltoall_block","half_alltoall_block","float_alltoall_block","double_alltoall_block","char_alltoall_block","short_alltoall_block","schar_alltoall_block","int_alltoall_block","long_alltoall_block","longlong_alltoall_block","uchar_alltoall_block","ushort_alltoall_block","uint_alltoall_block","ulong_alltoall_block","ulonglong_alltoall_block","int8_alltoall_block","int16_alltoall_block","int32_alltoall_block","int64_alltoall_block","uint8_alltoall_block","uint16_alltoall_block","uint32_alltoall_block","uint64_alltoall_block","size_alltoall_block","ptrdiff_alltoall_block","barrier_warp","barrier_warpgroup","barrier_block","barrier_all_warp","barrier_all_block","team_sync_warp","team_sync_block","sync_all_warp","sync_all_block","broadcastmem_warp","broadcastmem_block","bfloat16_broadcast_warp","half_broadcast_warp","float_broadcast_warp","double_broadcast_warp","char_broadcast_warp","short_broadcast_warp","schar_broadcast_warp","int_broadcast_warp","long_broadcast_warp","longlong_broadcast_warp","uchar_broadcast_warp","ushort_broadcast_warp","uint_broadcast_warp","ulong_broadcast_warp","ulonglong_broadcast_warp","int8_broadcast_warp","int16_broadcast_warp","int32_broadcast_warp","int64_broadcast_warp","uint8_broadcast_warp","uint16_broadcast_warp","uint32_broadcast_warp","uint64_broadcast_warp","size_broadcast_warp","ptrdiff_broadcast_warp","bfloat16_broadcast_block","half_broadcast_block","float_broadcast_block","double_broadcast_block","char_broadcast_block","short_broadcast_block","schar_broadcast_block","int_broadcast_block","long_broadcast_block","longlong_broadcast_block","uchar_broadcast_block","ushort_broadcast_block","uint_broadcast_block","ulong_broadcast_block","ulonglong_broadcast_block","int8_broadcast_block","int16_broadcast_block","int32_broadcast_block","int64_broadcast_block","uint8_broadcast_block","uint16_broadcast_block","uint32_broadcast_block","uint64_broadcast_block","size_broadcast_block","ptrdiff_broadcast_block","fcollectmem_warp","fcollectmem_block","bfloat16_fcollect_warp","half_fcollect_warp","float_fcollect_warp","double_fcollect_warp","char_fcollect_warp","short_fcollect_warp","schar_fcollect_warp","int_fcollect_warp","long_fcollect_warp","longlong_fcollect_warp","uchar_fcollect_warp","ushort_fcollect_warp","uint_fcollect_warp","ulong_fcollect_warp","ulonglong_fcollect_warp","int8_fcollect_warp","int16_fcollect_warp","int32_fcollect_warp","int64_fcollect_warp","uint8_fcollect_warp","uint16_fcollect_warp","uint32_fcollect_warp","uint64_fcollect_warp","size_fcollect_warp","ptrdiff_fcollect_warp","bfloat16_fcollect_block","half_fcollect_block","float_fcollect_block","double_fcollect_block","char_fcollect_block","short_fcollect_block","schar_fcollect_block","int_fcollect_block","long_fcollect_block","longlong_fcollect_block","uchar_fcollect_block","ushort_fcollect_block","uint_fcollect_block","ulong_fcollect_block","ulonglong_fcollect_block","int8_fcollect_block","int16_fcollect_block","int32_fcollect_block","int64_fcollect_block","uint8_fcollect_block","uint16_fcollect_block","uint32_fcollect_block","uint64_fcollect_block","size_fcollect_block","ptrdiff_fcollect_block","uchar_and_reduce_warp","ushort_and_reduce_warp","uint_and_reduce_warp","ulong_and_reduce_warp","ulonglong_and_reduce_warp","int8_and_reduce_warp","int16_and_reduce_warp","int32_and_reduce_warp","int64_and_reduce_warp","uint8_and_reduce_warp","uint16_and_reduce_warp","uint32_and_reduce_warp","uint64_and_reduce_warp","size_and_reduce_warp","uchar_or_reduce_warp","ushort_or_reduce_warp","uint_or_reduce_warp","ulong_or_reduce_warp","ulonglong_or_reduce_warp","int8_or_reduce_warp","int16_or_reduce_warp","int32_or_reduce_warp","int64_or_reduce_warp","uint8_or_reduce_warp","uint16_or_reduce_warp","uint32_or_reduce_warp","uint64_or_reduce_warp","size_or_reduce_warp","uchar_xor_reduce_warp","ushort_xor_reduce_warp","uint_xor_reduce_warp","ulong_xor_reduce_warp","ulonglong_xor_reduce_warp","int8_xor_reduce_warp","int16_xor_reduce_warp","int32_xor_reduce_warp","int64_xor_reduce_warp","uint8_xor_reduce_warp","uint16_xor_reduce_warp","uint32_xor_reduce_warp","uint64_xor_reduce_warp","size_xor_reduce_warp","uchar_max_reduce_warp","ushort_max_reduce_warp","uint_max_reduce_warp","ulong_max_reduce_warp","ulonglong_max_reduce_warp","int8_max_reduce_warp","int16_max_reduce_warp","int32_max_reduce_warp","int64_max_reduce_warp","uint8_max_reduce_warp","uint16_max_reduce_warp","uint32_max_reduce_warp","uint64_max_reduce_warp","size_max_reduce_warp","char_max_reduce_warp","schar_max_reduce_warp","short_max_reduce_warp","int_max_reduce_warp","long_max_reduce_warp","longlong_max_reduce_warp","bfloat16_max_reduce_warp","half_max_reduce_warp","float_max_reduce_warp","double_max_reduce_warp","uchar_min_reduce_warp","ushort_min_reduce_warp","uint_min_reduce_warp","ulong_min_reduce_warp","ulonglong_min_reduce_warp","int8_min_reduce_warp","int16_min_reduce_warp","int32_min_reduce_warp","int64_min_reduce_warp","uint8_min_reduce_warp","uint16_min_reduce_warp","uint32_min_reduce_warp","uint64_min_reduce_warp","size_min_reduce_warp","char_min_reduce_warp","schar_min_reduce_warp","short_min_reduce_warp","int_min_reduce_warp","long_min_reduce_warp","longlong_min_reduce_warp","bfloat16_min_reduce_warp","half_min_reduce_warp","float_min_reduce_warp","double_min_reduce_warp","uchar_sum_reduce_warp","ushort_sum_reduce_warp","uint_sum_reduce_warp","ulong_sum_reduce_warp","ulonglong_sum_reduce_warp","int8_sum_reduce_warp","int16_sum_reduce_warp","int32_sum_reduce_warp","int64_sum_reduce_warp","uint8_sum_reduce_warp","uint16_sum_reduce_warp","uint32_sum_reduce_warp","uint64_sum_reduce_warp","size_sum_reduce_warp","char_sum_reduce_warp","schar_sum_reduce_warp","short_sum_reduce_warp","int_sum_reduce_warp","long_sum_reduce_warp","longlong_sum_reduce_warp","bfloat16_sum_reduce_warp","half_sum_reduce_warp","float_sum_reduce_warp","double_sum_reduce_warp","uchar_prod_reduce_warp","ushort_prod_reduce_warp","uint_prod_reduce_warp","ulong_prod_reduce_warp","ulonglong_prod_reduce_warp","int8_prod_reduce_warp","int16_prod_reduce_warp","int32_prod_reduce_warp","int64_prod_reduce_warp","uint8_prod_reduce_warp","uint16_prod_reduce_warp","uint32_prod_reduce_warp","uint64_prod_reduce_warp","size_prod_reduce_warp","char_prod_reduce_warp","schar_prod_reduce_warp","short_prod_reduce_warp","int_prod_reduce_warp","long_prod_reduce_warp","longlong_prod_reduce_warp","bfloat16_prod_reduce_warp","half_prod_reduce_warp","float_prod_reduce_warp","double_prod_reduce_warp","uchar_and_reduce_block","ushort_and_reduce_block","uint_and_reduce_block","ulong_and_reduce_block","ulonglong_and_reduce_block","int8_and_reduce_block","int16_and_reduce_block","int32_and_reduce_block","int64_and_reduce_block","uint8_and_reduce_block","uint16_and_reduce_block","uint32_and_reduce_block","uint64_and_reduce_block","size_and_reduce_block","uchar_or_reduce_block","ushort_or_reduce_block","uint_or_reduce_block","ulong_or_reduce_block","ulonglong_or_reduce_block","int8_or_reduce_block","int16_or_reduce_block","int32_or_reduce_block","int64_or_reduce_block","uint8_or_reduce_block","uint16_or_reduce_block","uint32_or_reduce_block","uint64_or_reduce_block","size_or_reduce_block","uchar_xor_reduce_block","ushort_xor_reduce_block","uint_xor_reduce_block","ulong_xor_reduce_block","ulonglong_xor_reduce_block","int8_xor_reduce_block","int16_xor_reduce_block","int32_xor_reduce_block","int64_xor_reduce_block","uint8_xor_reduce_block","uint16_xor_reduce_block","uint32_xor_reduce_block","uint64_xor_reduce_block","size_xor_reduce_block","uchar_max_reduce_block","ushort_max_reduce_block","uint_max_reduce_block","ulong_max_reduce_block","ulonglong_max_reduce_block","int8_max_reduce_block","int16_max_reduce_block","int32_max_reduce_block","int64_max_reduce_block","uint8_max_reduce_block","uint16_max_reduce_block","uint32_max_reduce_block","uint64_max_reduce_block","size_max_reduce_block","char_max_reduce_block","schar_max_reduce_block","short_max_reduce_block","int_max_reduce_block","long_max_reduce_block","longlong_max_reduce_block","bfloat16_max_reduce_block","half_max_reduce_block","float_max_reduce_block","double_max_reduce_block","uchar_min_reduce_block","ushort_min_reduce_block","uint_min_reduce_block","ulong_min_reduce_block","ulonglong_min_reduce_block","int8_min_reduce_block","int16_min_reduce_block","int32_min_reduce_block","int64_min_reduce_block","uint8_min_reduce_block","uint16_min_reduce_block","uint32_min_reduce_block","uint64_min_reduce_block","size_min_reduce_block","char_min_reduce_block","schar_min_reduce_block","short_min_reduce_block","int_min_reduce_block","long_min_reduce_block","longlong_min_reduce_block","bfloat16_min_reduce_block","half_min_reduce_block","float_min_reduce_block","double_min_reduce_block","uchar_sum_reduce_block","ushort_sum_reduce_block","uint_sum_reduce_block","ulong_sum_reduce_block","ulonglong_sum_reduce_block","int8_sum_reduce_block","int16_sum_reduce_block","int32_sum_reduce_block","int64_sum_reduce_block","uint8_sum_reduce_block","uint16_sum_reduce_block","uint32_sum_reduce_block","uint64_sum_reduce_block","size_sum_reduce_block","char_sum_reduce_block","schar_sum_reduce_block","short_sum_reduce_block","int_sum_reduce_block","long_sum_reduce_block","longlong_sum_reduce_block","bfloat16_sum_reduce_block","half_sum_reduce_block","float_sum_reduce_block","double_sum_reduce_block","uchar_prod_reduce_block","ushort_prod_reduce_block","uint_prod_reduce_block","ulong_prod_reduce_block","ulonglong_prod_reduce_block","int8_prod_reduce_block","int16_prod_reduce_block","int32_prod_reduce_block","int64_prod_reduce_block","uint8_prod_reduce_block","uint16_prod_reduce_block","uint32_prod_reduce_block","uint64_prod_reduce_block","size_prod_reduce_block","char_prod_reduce_block","schar_prod_reduce_block","short_prod_reduce_block","int_prod_reduce_block","long_prod_reduce_block","longlong_prod_reduce_block","bfloat16_prod_reduce_block","half_prod_reduce_block","float_prod_reduce_block","double_prod_reduce_block","uchar_and_reducescatter_warp","ushort_and_reducescatter_warp","uint_and_reducescatter_warp","ulong_and_reducescatter_warp","ulonglong_and_reducescatter_warp","int8_and_reducescatter_warp","int16_and_reducescatter_warp","int32_and_reducescatter_warp","int64_and_reducescatter_warp","uint8_and_reducescatter_warp","uint16_and_reducescatter_warp","uint32_and_reducescatter_warp","uint64_and_reducescatter_warp","size_and_reducescatter_warp","uchar_or_reducescatter_warp","ushort_or_reducescatter_warp","uint_or_reducescatter_warp","ulong_or_reducescatter_warp","ulonglong_or_reducescatter_warp","int8_or_reducescatter_warp","int16_or_reducescatter_warp","int32_or_reducescatter_warp","int64_or_reducescatter_warp","uint8_or_reducescatter_warp","uint16_or_reducescatter_warp","uint32_or_reducescatter_warp","uint64_or_reducescatter_warp","size_or_reducescatter_warp","uchar_xor_reducescatter_warp","ushort_xor_reducescatter_warp","uint_xor_reducescatter_warp","ulong_xor_reducescatter_warp","ulonglong_xor_reducescatter_warp","int8_xor_reducescatter_warp","int16_xor_reducescatter_warp","int32_xor_reducescatter_warp","int64_xor_reducescatter_warp","uint8_xor_reducescatter_warp","uint16_xor_reducescatter_warp","uint32_xor_reducescatter_warp","uint64_xor_reducescatter_warp","size_xor_reducescatter_warp","uchar_max_reducescatter_warp","ushort_max_reducescatter_warp","uint_max_reducescatter_warp","ulong_max_reducescatter_warp","ulonglong_max_reducescatter_warp","int8_max_reducescatter_warp","int16_max_reducescatter_warp","int32_max_reducescatter_warp","int64_max_reducescatter_warp","uint8_max_reducescatter_warp","uint16_max_reducescatter_warp","uint32_max_reducescatter_warp","uint64_max_reducescatter_warp","size_max_reducescatter_warp","char_max_reducescatter_warp","schar_max_reducescatter_warp","short_max_reducescatter_warp","int_max_reducescatter_warp","long_max_reducescatter_warp","longlong_max_reducescatter_warp","bfloat16_max_reducescatter_warp","half_max_reducescatter_warp","float_max_reducescatter_warp","double_max_reducescatter_warp","uchar_min_reducescatter_warp","ushort_min_reducescatter_warp","uint_min_reducescatter_warp","ulong_min_reducescatter_warp","ulonglong_min_reducescatter_warp","int8_min_reducescatter_warp","int16_min_reducescatter_warp","int32_min_reducescatter_warp","int64_min_reducescatter_warp","uint8_min_reducescatter_warp","uint16_min_reducescatter_warp","uint32_min_reducescatter_warp","uint64_min_reducescatter_warp","size_min_reducescatter_warp","char_min_reducescatter_warp","schar_min_reducescatter_warp","short_min_reducescatter_warp","int_min_reducescatter_warp","long_min_reducescatter_warp","longlong_min_reducescatter_warp","bfloat16_min_reducescatter_warp","half_min_reducescatter_warp","float_min_reducescatter_warp","double_min_reducescatter_warp","uchar_sum_reducescatter_warp","ushort_sum_reducescatter_warp","uint_sum_reducescatter_warp","ulong_sum_reducescatter_warp","ulonglong_sum_reducescatter_warp","int8_sum_reducescatter_warp","int16_sum_reducescatter_warp","int32_sum_reducescatter_warp","int64_sum_reducescatter_warp","uint8_sum_reducescatter_warp","uint16_sum_reducescatter_warp","uint32_sum_reducescatter_warp","uint64_sum_reducescatter_warp","size_sum_reducescatter_warp","char_sum_reducescatter_warp","schar_sum_reducescatter_warp","short_sum_reducescatter_warp","int_sum_reducescatter_warp","long_sum_reducescatter_warp","longlong_sum_reducescatter_warp","bfloat16_sum_reducescatter_warp","half_sum_reducescatter_warp","float_sum_reducescatter_warp","double_sum_reducescatter_warp","uchar_prod_reducescatter_warp","ushort_prod_reducescatter_warp","uint_prod_reducescatter_warp","ulong_prod_reducescatter_warp","ulonglong_prod_reducescatter_warp","int8_prod_reducescatter_warp","int16_prod_reducescatter_warp","int32_prod_reducescatter_warp","int64_prod_reducescatter_warp","uint8_prod_reducescatter_warp","uint16_prod_reducescatter_warp","uint32_prod_reducescatter_warp","uint64_prod_reducescatter_warp","size_prod_reducescatter_warp","char_prod_reducescatter_warp","schar_prod_reducescatter_warp","short_prod_reducescatter_warp","int_prod_reducescatter_warp","long_prod_reducescatter_warp","longlong_prod_reducescatter_warp","bfloat16_prod_reducescatter_warp","half_prod_reducescatter_warp","float_prod_reducescatter_warp","double_prod_reducescatter_warp","uchar_and_reducescatter_block","ushort_and_reducescatter_block","uint_and_reducescatter_block","ulong_and_reducescatter_block","ulonglong_and_reducescatter_block","int8_and_reducescatter_block","int16_and_reducescatter_block","int32_and_reducescatter_block","int64_and_reducescatter_block","uint8_and_reducescatter_block","uint16_and_reducescatter_block","uint32_and_reducescatter_block","uint64_and_reducescatter_block","size_and_reducescatter_block","uchar_or_reducescatter_block","ushort_or_reducescatter_block","uint_or_reducescatter_block","ulong_or_reducescatter_block","ulonglong_or_reducescatter_block","int8_or_reducescatter_block","int16_or_reducescatter_block","int32_or_reducescatter_block","int64_or_reducescatter_block","uint8_or_reducescatter_block","uint16_or_reducescatter_block","uint32_or_reducescatter_block","uint64_or_reducescatter_block","size_or_reducescatter_block","uchar_xor_reducescatter_block","ushort_xor_reducescatter_block","uint_xor_reducescatter_block","ulong_xor_reducescatter_block","ulonglong_xor_reducescatter_block","int8_xor_reducescatter_block","int16_xor_reducescatter_block","int32_xor_reducescatter_block","int64_xor_reducescatter_block","uint8_xor_reducescatter_block","uint16_xor_reducescatter_block","uint32_xor_reducescatter_block","uint64_xor_reducescatter_block","size_xor_reducescatter_block","uchar_max_reducescatter_block","ushort_max_reducescatter_block","uint_max_reducescatter_block","ulong_max_reducescatter_block","ulonglong_max_reducescatter_block","int8_max_reducescatter_block","int16_max_reducescatter_block","int32_max_reducescatter_block","int64_max_reducescatter_block","uint8_max_reducescatter_block","uint16_max_reducescatter_block","uint32_max_reducescatter_block","uint64_max_reducescatter_block","size_max_reducescatter_block","char_max_reducescatter_block","schar_max_reducescatter_block","short_max_reducescatter_block","int_max_reducescatter_block","long_max_reducescatter_block","longlong_max_reducescatter_block","bfloat16_max_reducescatter_block","half_max_reducescatter_block","float_max_reducescatter_block","double_max_reducescatter_block","uchar_min_reducescatter_block","ushort_min_reducescatter_block","uint_min_reducescatter_block","ulong_min_reducescatter_block","ulonglong_min_reducescatter_block","int8_min_reducescatter_block","int16_min_reducescatter_block","int32_min_reducescatter_block","int64_min_reducescatter_block","uint8_min_reducescatter_block","uint16_min_reducescatter_block","uint32_min_reducescatter_block","uint64_min_reducescatter_block","size_min_reducescatter_block","char_min_reducescatter_block","schar_min_reducescatter_block","short_min_reducescatter_block","int_min_reducescatter_block","long_min_reducescatter_block","longlong_min_reducescatter_block","bfloat16_min_reducescatter_block","half_min_reducescatter_block","float_min_reducescatter_block","double_min_reducescatter_block","uchar_sum_reducescatter_block","ushort_sum_reducescatter_block","uint_sum_reducescatter_block","ulong_sum_reducescatter_block","ulonglong_sum_reducescatter_block","int8_sum_reducescatter_block","int16_sum_reducescatter_block","int32_sum_reducescatter_block","int64_sum_reducescatter_block","uint8_sum_reducescatter_block","uint16_sum_reducescatter_block","uint32_sum_reducescatter_block","uint64_sum_reducescatter_block","size_sum_reducescatter_block","char_sum_reducescatter_block","schar_sum_reducescatter_block","short_sum_reducescatter_block","int_sum_reducescatter_block","long_sum_reducescatter_block","longlong_sum_reducescatter_block","bfloat16_sum_reducescatter_block","half_sum_reducescatter_block","float_sum_reducescatter_block","double_sum_reducescatter_block","uchar_prod_reducescatter_block","ushort_prod_reducescatter_block","uint_prod_reducescatter_block","ulong_prod_reducescatter_block","ulonglong_prod_reducescatter_block","int8_prod_reducescatter_block","int16_prod_reducescatter_block","int32_prod_reducescatter_block","int64_prod_reducescatter_block","uint8_prod_reducescatter_block","uint16_prod_reducescatter_block","uint32_prod_reducescatter_block","uint64_prod_reducescatter_block","size_prod_reducescatter_block","char_prod_reducescatter_block","schar_prod_reducescatter_block","short_prod_reducescatter_block","int_prod_reducescatter_block","long_prod_reducescatter_block","longlong_prod_reducescatter_block","bfloat16_prod_reducescatter_block","half_prod_reducescatter_block","float_prod_reducescatter_block","double_prod_reducescatter_block","double2_maxloc_reduce_block"]


__all__ = _NBTYPE_SYMBOLS + _RECORD_SYMBOLS + _FUNCTION_SYMBOLS

