stored in `package.cpath`. If that also fails,
        it tries an `all-in-one` loader (see below).

        When loading a C library, `require` first uses a dynamic link facility
        to link the application with the library. Then it tries to find a C
        function inside this library to be used as the loader. The name of
        this C function is the string `"luaopen_"` concatenated with a copy of
        the module name where each dot is replaced by an underscore. Moreover,
        if the module name has a hyphen, its prefix up to (and including) the
        first hyphen is removed. For instance, if the module name is
        `a.v1-b.c`, the function name will be `luaopen_b_c`.

        If `require` finds neither a Lua library nor a C library for a module,
        it calls the `all-in-one loader`. This loader searches the C path for
        a library for the root name of the given module. For instance, when
        requiring `a.b.c`, it will search for a C library for `a`. If found,
        it looks into it for an open function for the submodule; in our
        example, that would be `luaopen_a_b_c`. With this facility, a package
        can pack several C submodules into one single library, with each
        submodule keeping its original open function.

        Once a loader is found, `require` calls the loader with a single
        argument, {modname}. If the loader returns any value, `require`
        assigns the returned value to `package.loaded[modname]`. If the loader
        returns no value and has not assigned any value to
        `package.loaded[modname]`, then `require` assigns `true` to this
        entry. In any case, `require` returns the final value of
        `package.loaded[modname]`.

        If there is any error loading or running the module, or if it cannot
        find any loader for the module, then `require` signals an error.

package.cpath                                                    *package.cpath*
        The path used by `require` to search for a C loader.

        Lua initializes the C path `package.cpath` in the same way it
        initializes the Lua path `package.path`, using the environment
        variable `LUA_CPATH` (plus another default path defined in
        `luaconf.h`).

package.loaded                                                  *package.loaded*
        A table used by `require` to control which modules are already loaded.
        When you require a module `modname` and `package.loaded[modname]` is
        not false, `require` simply returns the value stored there.

package.loadlib({libname}, {funcname})                       *package.loadlib()*
        Dynamically links the host program with the C library {libname}.
        Inside this library, looks for a function {funcname} and returns this
        function as a C function. (So, {funcname} must follow the protocol
        (see |lua_CFunction|)).

        This is a low-level function. It completely bypasses the package and
        module system. Unlike `require`, it does not perform any path
        searching and does not automatically adds extensions. {libname} must
        be the complete file name of the C library, including if necessary a
        path and extension. {funcname} must be the exact name exported by the
        C library (which may depend on the C compiler and linker used).

        This function is not supported by ANSI C. As such, it is only
        available on some platforms (Windows, Linux, Mac OS X, Solaris, BSD,
        plus other Unix systems that support the `dlfcn` standard).

package.path                                                      *package.path*
        The path used by `require` to search for a Lua loader.

        At start-up, Lua initializes this variable with the value of the
        environment variable `LUA_PATH` or with a default path defined in
        `luaconf.h`, if the environment variable is not defined. Any `";;"` in
        the value of the environment variable is