** fill a closure with new closed upvalues */

** Error when both values are convertible to numbers, but not to integers */

** Process 1st operand 'v' of binary operation 'op' before reading ** 2nd operand. */

** Finalize code for binary operation, after reading 2nd operand. ** For '(a .. b .. c)' (which is '(a .. (b .. c))', because ** concatenation is righ

** Aplly prefix operation 'op' to expression 'e'. */

** Emit SELF instruction (convert expression 'e' into 'e:key(e,'). */

** Fix an expression to return the number of results 'nresults'. ** Either 'e' is a multi-ret expression (function call or vararg) ** or 'nresults' is

** Add a string to list of constants and return its index. */

** Clear API string cache. (Entries cannot be empty, so fill them with ** a non-collectable string.) */

** equality for long strings */

** Initialize the string table and the string cache */

** finish execution of an opcode interrupted by an yield */

--------------------------------------------------------------- read --- */

** convert an hexadecimal numeric string to a number, following ** C99 specification for 'strtod' */

** compiles the main function, which is a regular vararg function with an ** upvalue named LUA_ENV */

** Convert a string mask (for 'sethook') into a bit mask */

Mark block where variable at given level was defined (to emit close instructions later). */

** export pending gotos to outer level, to check them against ** outer labels; if the block being exited has upvalues, and ** the goto exits the scope

** Given 'nres' results at 'firstResult', move 'wanted' of them to 'res'. ** Handle most typical cases (zero results for commands, one result for ** e

** Add nil to list of constants and return its index. */

** return registry.LUA_NOENV as a boolean */

check whether pattern has no special characters */

** Count keys in array part of table 't': Fill 'nums[i]' with ** number of keys that will go into corresponding slice and return ** total number of no

** Does the partition: Pivot P is at the top of the stack. ** precondition: a[lo] <= P == a[up-1] <= a[up], ** so it only needs to do the partition fr